diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index 6ad430750..4fb67fbfe 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -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
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 2a6b1f2a0..25606eee2 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -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
diff --git a/.github/workflows/language-smoke.yml b/.github/workflows/language-smoke.yml
index 03f80a688..b349d2d53 100644
--- a/.github/workflows/language-smoke.yml
+++ b/.github/workflows/language-smoke.yml
@@ -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:
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 1758e67a4..ed6644138 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -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
diff --git a/AGENTS.md b/AGENTS.md
index 54cc95ae4..50ad7debe 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -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
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 6e02bd6bf..2b4544255 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -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.
 
diff --git a/Cargo.lock b/Cargo.lock
index 317a7da60..5a3e48cb0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -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"
diff --git a/Cargo.toml b/Cargo.toml
index ea4e1506d..507145e37 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -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"
diff --git a/README.md b/README.md
index 0e0ca9dc7..50ea82fd9 100644
--- a/README.md
+++ b/README.md
@@ -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).
diff --git a/crates/ide-agent/src/registry.rs b/crates/ide-agent/src/registry.rs
index 602a4a1cc..0fcc5eb73 100644
--- a/crates/ide-agent/src/registry.rs
+++ b/crates/ide-agent/src/registry.rs
@@ -76,6 +76,8 @@ pub struct RegistryAgent {
     pub installed: Option<String>,
     /// Whether [`Self::version`] is newer than the installed one.
     pub update: bool,
+    /// An install of it is running (it goes on after the Settings page that started it closes).
+    pub installing: bool,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Type)]
@@ -332,6 +334,7 @@ fn visible(
                 distribution,
                 no_checksum,
                 installed,
+                installing: false,
             })
         })
         .collect();
diff --git a/crates/ide-android/Cargo.toml b/crates/ide-android/Cargo.toml
new file mode 100644
index 000000000..21c049e4d
--- /dev/null
+++ b/crates/ide-android/Cargo.toml
@@ -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
diff --git a/crates/ide-android/src/lib.rs b/crates/ide-android/src/lib.rs
new file mode 100644
index 000000000..ade335cdb
--- /dev/null
+++ b/crates/ide-android/src/lib.rs
@@ -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());
+        }
+    }
+}
diff --git a/crates/ide-android/src/model.rs b/crates/ide-android/src/model.rs
new file mode 100644
index 000000000..1bbada32d
--- /dev/null
+++ b/crates/ide-android/src/model.rs
@@ -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);
+    }
+}
diff --git a/crates/ide-android/src/process.rs b/crates/ide-android/src/process.rs
new file mode 100644
index 000000000..b5b858389
--- /dev/null
+++ b/crates/ide-android/src/process.rs
@@ -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:?}");
+    }
+}
diff --git a/crates/ide-android/tests/device.rs b/crates/ide-android/tests/device.rs
new file mode 100644
index 000000000..d8afd6c52
--- /dev/null
+++ b/crates/ide-android/tests/device.rs
@@ -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");
+}
diff --git a/crates/ide-build/src/application_update.rs b/crates/ide-build/src/application_update.rs
index cabd8a736..96a7ad0d8 100644
--- a/crates/ide-build/src/application_update.rs
+++ b/crates/ide-build/src/application_update.rs
@@ -40,7 +40,7 @@ pub fn plan(root: &Path, model: &BuildModel, module: &Path, cache: &Path) -> Ide
             kind: "maven",
         });
     }
-    if let Some(g) = &model.gradle
+    if let Some(g) = model.gradle_for_module(root, &module)
         && let Some(p) = g.projects.iter().find(|p| root.join(&p.dir) == module)
     {
         let script = cache.join("resources.init.gradle");
@@ -163,11 +163,11 @@ mod tests {
         assert!(maven.args.contains(&"-Dexpression=project.build.outputDirectory".into()));
         assert_eq!(maven.env["JAVA_HOME"], "/jdk");
         model.maven = None;
-        model.gradle = Some(crate::GradleModel {
+        model.gradle = vec![crate::GradleModel {
             command: "/tools/gradlew".into(),
             projects: vec![crate::GradleProject { path: ":app".into(), dir: "app".into(), ..Default::default() }],
             ..Default::default()
-        });
+        }];
         let gradle = plan(&root, &model, Path::new("app"), &cache).unwrap();
         assert_eq!(gradle.command, "/tools/gradlew");
         assert_eq!(gradle.args.last().unwrap(), ":app:openideaUpdateResources");
diff --git a/crates/ide-build/src/compile/mod.rs b/crates/ide-build/src/compile/mod.rs
index 603d5b3ff..91bbdbf35 100644
--- a/crates/ide-build/src/compile/mod.rs
+++ b/crates/ide-build/src/compile/mod.rs
@@ -147,7 +147,9 @@ fn detect_dir(dir: &Path, model: &BuildModel, root: &Path) -> Option<BuildSystem
     let rel = rel_str(root, dir);
     if model.maven.as_ref().is_some_and(|m| m.projects.iter().any(|p| p.dir == rel)) || has(dir, &["pom.xml"]) {
         Some(BuildSystem::Maven)
-    } else if has(dir, &["build.gradle", "build.gradle.kts", "settings.gradle", "settings.gradle.kts"]) {
+    } else if model.gradle_for_module(root, dir).is_some()
+        || has(dir, &["build.gradle", "build.gradle.kts", "settings.gradle", "settings.gradle.kts"])
+    {
         Some(BuildSystem::Gradle)
     } else if has(dir, &["Cargo.toml"]) {
         Some(BuildSystem::Cargo)
@@ -162,16 +164,13 @@ fn detect_dir(dir: &Path, model: &BuildModel, root: &Path) -> Option<BuildSystem
     }
 }
 
-/// `root/rel`, without a trailing separator for the root itself.
-/// `root` / `rel`, joined per `/`-separated component: on Windows a single join of
-/// `a/b` keeps the `/`, and such a path does not compare equal to the same directory
-/// as other tools (JDT LS) spell it.
+/// Resolves a workspace-relative or absolute directory with native path separators.
 fn subdir(root: &Path, rel: &str) -> PathBuf {
-    rel.split('/').filter(|part| !part.is_empty()).fold(root.to_path_buf(), |path, part| path.join(part))
+    root.join(rel).components().collect()
 }
 
 fn rel_str(root: &Path, dir: &Path) -> String {
-    dir.strip_prefix(root).map(|r| r.to_string_lossy().replace('\\', "/")).unwrap_or_default()
+    dir.strip_prefix(root).unwrap_or(dir).to_string_lossy().replace('\\', "/")
 }
 
 /// Directories from `file`'s folder up to `root` (inclusive).
@@ -192,7 +191,14 @@ pub fn plan(
     let project_name = root.file_name().map_or_else(|| "project".to_owned(), |n| n.to_string_lossy().into_owned());
     let module_dir = match file {
         Some(f) => {
-            let dir = ancestors_within(root, f)
+            let scope = model
+                .gradle
+                .iter()
+                .flat_map(|g| std::iter::once(root.join(&g.dir)).chain(g.projects.iter().map(|p| root.join(&p.dir))))
+                .filter(|dir| f.starts_with(dir))
+                .max_by_key(|dir| dir.components().count())
+                .unwrap_or_else(|| root.to_path_buf());
+            let dir = ancestors_within(&scope, f)
                 .find(|d| detect_dir(d, model, root).is_some())
                 .ok_or_else(|| IdeError::not_found(format!("{} is not in a module", f.display())))?;
             Some(dir.to_path_buf())
@@ -202,7 +208,7 @@ pub fn plan(
     let dir = module_dir.clone().unwrap_or_else(|| root.to_path_buf());
     // A folder of sibling projects has no build file itself; its Maven projects are built one by one.
     let system = detect_dir(&dir, model, root)
-        .or_else(|| if model.gradle.is_some() { Some(BuildSystem::Gradle) } else { None })
+        .or((!model.gradle.is_empty()).then_some(BuildSystem::Gradle))
         .or_else(|| model.maven.as_ref().filter(|m| !m.projects.is_empty()).map(|_| BuildSystem::Maven))
         .ok_or_else(|| {
             IdeError::not_found("no supported build system (Maven, Gradle, Cargo, Go, TypeScript, CMake) found")
@@ -270,14 +276,16 @@ fn maven_steps(root: &Path, model: &BuildModel, kind: BuildKind, module: Option<
 }
 
 fn gradle_steps(root: &Path, model: &BuildModel, kind: BuildKind, module: Option<&Path>) -> IdeResult<Vec<BuildStep>> {
-    let fallback;
-    let g = match &model.gradle {
-        Some(g) => g,
-        None => {
-            fallback = crate::gradle::load(root).ok_or_else(|| IdeError::not_found("no Gradle build found"))?;
-            &fallback
-        }
-    };
+    if module.is_none() && !model.gradle.is_empty() {
+        return Ok(model.gradle.iter().flat_map(|g| gradle_step(root, g, kind, None)).collect());
+    }
+    let g = module
+        .and_then(|m| model.gradle_for_module(root, m))
+        .ok_or_else(|| IdeError::not_found("module does not belong to a linked Gradle build"))?;
+    Ok(gradle_step(root, g, kind, module))
+}
+
+fn gradle_step(root: &Path, g: &crate::GradleModel, kind: BuildKind, module: Option<&Path>) -> Vec<BuildStep> {
     let prefix = module
         .and_then(|m| {
             let rel = rel_str(root, m);
@@ -296,7 +304,7 @@ fn gradle_steps(root: &Path, model: &BuildModel, kind: BuildKind, module: Option
     let mut s = BuildStep::new(&g.command, &["--console=plain"], &subdir(root, &g.dir), Format::Gradle);
     s.args.extend(tasks);
     s.env = g.env.clone();
-    Ok(vec![s])
+    vec![s]
 }
 
 fn cargo_steps(dir: &Path, kind: BuildKind) -> Vec<BuildStep> {
@@ -811,6 +819,79 @@ fn launch_class_dirs(system: BuildSystem, module: &Path, test: bool) -> Vec<Path
 
 #[cfg(test)]
 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(wrapper), "").unwrap();
+        }
+        let settings = ide_core::settings::GradleSettings {
+            linked_projects: Some(vec!["a".into(), "b".into()]),
+            ..Default::default()
+        };
+        let mut model = crate::load_linked(root, &root.join("cache"), None, &Default::default(), &settings);
+        model.gradle[0].env.insert("JAVA_HOME".into(), "/jdk-a".into());
+        model.gradle[1].env.insert("JAVA_HOME".into(), "/jdk-b".into());
+        let all = super::plan(root, &model, super::BuildKind::Build, None, None).unwrap();
+        assert_eq!(all.steps.len(), 2);
+        assert_eq!(all.steps[0].cwd, root.join("a"));
+        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").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"]);
+        // A directly linked build owns its module even when another composite reports it too.
+        let direct = model.gradle[1].projects[0].clone();
+        model.gradle[0].projects.push(direct);
+        assert_eq!(model.gradle_for_module(root, &root.join("b")).unwrap().dir, "b");
+        let mut nested = model.gradle[1].projects[1].clone();
+        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").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());
+    }
+
+    #[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");
+        let external = base.join("external");
+        std::fs::create_dir(&root).unwrap();
+        std::fs::create_dir_all(external.join("app/src/main/java")).unwrap();
+        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(wrapper), "").unwrap();
+        let settings = ide_core::settings::GradleSettings {
+            linked_projects: Some(vec![external.to_string_lossy().into_owned()]),
+            ..Default::default()
+        };
+        let mut model = crate::load_linked(&root, &base.join("cache"), None, &Default::default(), &settings);
+        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(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");
+        assert_eq!(module.steps[0].args, ["--console=plain", ":app:clean", ":app:classes", ":app:testClasses"]);
+        let other = base.join("unlinked");
+        std::fs::create_dir(&other).unwrap();
+        std::fs::write(other.join("build.gradle"), "").unwrap();
+        assert!(super::plan(&root, &model, super::BuildKind::Build, Some(&other), None).is_err());
+    }
     use super::*;
 
     /// Launch outputs use the platform separator throughout, so they compare equal to
diff --git a/crates/ide-build/src/gradle.rs b/crates/ide-build/src/gradle.rs
index 2ebf58489..b4bc88396 100644
--- a/crates/ide-build/src/gradle.rs
+++ b/crates/ide-build/src/gradle.rs
@@ -435,6 +435,17 @@ pub fn external_roots<'a>(root: &Path, dirs: impl IntoIterator<Item = &'a str>)
 
 pub fn load(root: &Path) -> Option<GradleModel> {
     let dir = build_dir(root)?;
+    load_build(root, dir.strip_prefix(root).unwrap_or(&dir))
+}
+
+/// Loads exactly this build, without searching its child folders.
+pub fn load_build(root: &Path, dir: &Path) -> Option<GradleModel> {
+    // 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;
+    }
     let settings = read_first(&dir, SETTINGS_FILES).map(|(_, t)| parse_settings(&t)).unwrap_or_default();
     let root_name =
         settings.name.unwrap_or_else(|| dir.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default());
@@ -455,6 +466,65 @@ pub fn load(root: &Path) -> Option<GradleModel> {
     Some(GradleModel { dir: rel(root, &dir), projects, java_version, command: wrapper(&dir), ..GradleModel::default() })
 }
 
+/// Validates user-selected build folders and stores a stable, deduplicated identity.
+pub fn normalize_linked_projects(root: &Path, dirs: &[String]) -> ide_core::IdeResult<Vec<String>> {
+    let root = dunce::canonicalize(root)?;
+    let mut out = Vec::new();
+    for dir in dirs {
+        let path = dunce::canonicalize(root.join(dir))?;
+        if !path.is_dir() || !SETTINGS_FILES.iter().chain(BUILD_FILES).any(|name| path.join(name).is_file()) {
+            return Err(ide_core::IdeError::invalid(format!("No Gradle build in {}", path.display())));
+        }
+        let dir = rel(&root, &path);
+        if !out.contains(&dir) {
+            out.push(dir);
+        }
+    }
+    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 {
+        None => build_dir(root).map(|dir| rel(root, &dir)).into_iter().collect(),
+        Some(dirs) => {
+            let mut out = Vec::new();
+            for dir in dirs {
+                if let Ok(dirs) = normalize_linked_projects(root, std::slice::from_ref(dir)) {
+                    for dir in dirs {
+                        if !out.contains(&dir) {
+                            out.push(dir);
+                        }
+                    }
+                }
+            }
+            out
+        }
+    }
+}
+
+pub fn load_linked(root: &Path, settings: &ide_core::settings::GradleSettings) -> Vec<GradleModel> {
+    linked_dirs(root, settings).iter().filter_map(|dir| load_build(root, Path::new(dir))).collect()
+}
+
+/// A build's task paths are local to it, so sync caches must be local to its identity too.
+pub fn cache_dir(cache: &Path, build_dir: &str) -> PathBuf {
+    if build_dir.is_empty() {
+        return cache.to_path_buf();
+    }
+    let hash = build_dir.bytes().fold(0xcbf29ce484222325u64, |h, b| (h ^ u64::from(b)).wrapping_mul(0x100000001b3));
+    cache.join("gradle").join(format!("{hash:016x}"))
+}
+
 /// `JavaLanguageVersion.of(21)` / `sourceCompatibility = JavaVersion.VERSION_17` in a build script.
 pub fn script_java_version(text: &str) -> Option<u32> {
     let number = |s: &str| -> Option<u32> {
@@ -616,6 +686,65 @@ 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();
+        let root = temp.path();
+        for dir in ["a", "b"] {
+            std::fs::create_dir(root.join(dir)).unwrap();
+            std::fs::write(root.join(dir).join("settings.gradle"), format!("rootProject.name = '{dir}'")).unwrap();
+        }
+        assert_eq!(super::load_linked(root, &Default::default())[0].dir, "a");
+        let mut settings = ide_core::settings::GradleSettings {
+            linked_projects: Some(vec!["b".into(), "./b".into(), "a".into()]),
+            ..Default::default()
+        };
+        let models = super::load_linked(root, &settings);
+        assert_eq!(models.iter().map(|g| g.dir.as_str()).collect::<Vec<_>>(), ["b", "a"]);
+        settings.linked_projects = Some(vec![]);
+        assert!(super::load_linked(root, &settings).is_empty());
+        assert!(super::normalize_linked_projects(root, &["missing".into()]).is_err());
+        assert!(super::normalize_linked_projects(root, &["".into()]).is_err());
+        assert!(super::load_build(root, root).is_none(), "exact loading never picks a child");
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn linked_directories_deduplicate_symlinks_and_keep_external_builds() {
+        let temp = tempfile::tempdir().unwrap();
+        let root = temp.path().join("workspace");
+        let external = temp.path().join("external");
+        std::fs::create_dir(&root).unwrap();
+        std::fs::create_dir(&external).unwrap();
+        std::fs::write(external.join("build.gradle"), "").unwrap();
+        std::os::unix::fs::symlink(&external, root.join("alias")).unwrap();
+        let dirs = super::normalize_linked_projects(&root, &["alias".into(), "../external".into()]).unwrap();
+        assert_eq!(dirs, [external.canonicalize().unwrap().to_string_lossy().to_string()]);
+    }
     #[test]
     fn script_dependencies_read_string_and_map_notations() {
         let script = r#"
diff --git a/crates/ide-build/src/gradle_deps.rs b/crates/ide-build/src/gradle_deps.rs
index 40c902029..109fea96f 100644
--- a/crates/ide-build/src/gradle_deps.rs
+++ b/crates/ide-build/src/gradle_deps.rs
@@ -126,6 +126,7 @@ fn project_path(text: &str) -> String {
 /// `configuration` and returns its tree.
 pub fn gradle_dependencies(
     root: &Path,
+    model: &gradle::GradleModel,
     options: &SyncOptions,
     project: &str,
     configuration: &str,
@@ -137,7 +138,6 @@ pub fn gradle_dependencies(
     if !project.starts_with(':') || project.chars().any(char::is_whitespace) {
         return Err(IdeError::invalid(format!("not a Gradle project path: {project}")));
     }
-    let model = gradle::load(root).ok_or_else(|| IdeError::not_found("no Gradle build in this project"))?;
     let task = if project == ":" { ":dependencies".to_owned() } else { format!("{project}:dependencies") };
     let mut args: Vec<String> =
         vec!["--console=plain".into(), "-q".into(), task, "--configuration".into(), configuration.into()];
@@ -226,8 +226,12 @@ runtimeClasspath - Runtime classpath of source set 'main'.
         let tmp = tempfile::tempdir().unwrap();
         let options = SyncOptions::default();
         let cancel = CancellationToken::new();
-        assert!(gradle_dependencies(tmp.path(), &options, ":", "x --init-script y", &cancel).is_err());
-        assert!(gradle_dependencies(tmp.path(), &options, "app", "runtimeClasspath", &cancel).is_err());
+        assert!(
+            gradle_dependencies(tmp.path(), &Default::default(), &options, ":", "x --init-script y", &cancel).is_err()
+        );
+        assert!(
+            gradle_dependencies(tmp.path(), &Default::default(), &options, "app", "runtimeClasspath", &cancel).is_err()
+        );
     }
 
     #[cfg(unix)]
@@ -246,8 +250,15 @@ runtimeClasspath - Runtime classpath of source set 'main'.
             offline: true,
             ..Default::default()
         };
-        let tree =
-            gradle_dependencies(root, &options, ":app", "testRuntimeClasspath", &CancellationToken::new()).unwrap();
+        let tree = gradle_dependencies(
+            root,
+            &gradle::load(root).unwrap(),
+            &options,
+            ":app",
+            "testRuntimeClasspath",
+            &CancellationToken::new(),
+        )
+        .unwrap();
         assert_eq!(tree, vec![dep("org.a", "b", Some("1.0"))]);
         assert_eq!(
             std::fs::read_to_string(root.join("args")).unwrap().trim(),
diff --git a/crates/ide-build/src/lib.rs b/crates/ide-build/src/lib.rs
index ab0588c45..eb613c5cf 100644
--- a/crates/ide-build/src/lib.rs
+++ b/crates/ide-build/src/lib.rs
@@ -20,7 +20,9 @@ mod xml;
 pub use gradle::{GradleModel, GradleProject, GradleTask};
 pub use gradle_deps::{GradleDependency, gradle_dependencies};
 pub use maven::{MavenDependency, MavenModel, MavenPlugin, MavenProfile, MavenProject, Omission};
-pub use sync::{SyncOptions, SyncProgress, maven_profiles, save_maven_profiles, sync_gradle, sync_maven};
+pub use sync::{
+    SyncOptions, SyncProgress, maven_profiles, save_maven_profiles, sync_gradle, sync_gradle_model, sync_maven,
+};
 
 use serde::{Deserialize, Serialize};
 use specta::Type;
@@ -38,13 +40,31 @@ pub enum BuildTool {
 #[serde(rename_all = "camelCase")]
 pub struct BuildModel {
     pub maven: Option<MavenModel>,
-    pub gradle: Option<GradleModel>,
+    #[serde(default)]
+    pub gradle: Vec<GradleModel>,
+}
+
+impl BuildModel {
+    /// Prefer the deepest linked build owning the module over a composite including it.
+    pub fn gradle_for_module(&self, root: &Path, module: &Path) -> Option<&GradleModel> {
+        let module = root.join(module);
+        self.gradle.iter().filter(|g| g.projects.iter().any(|p| root.join(&p.dir) == module)).min_by_key(|g| {
+            let dir = root.join(&g.dir);
+            std::cmp::Reverse(if module.starts_with(&dir) { dir.components().count() } else { 0 })
+        })
+    }
 }
 
 /// Static model of the builds under `root`, merged with the sync results cached in `cache_dir`.
 /// Parent POMs are looked up in `maven_repo` (the configured local repository), else the default one.
 pub fn load(root: &Path, cache_dir: &Path, maven_repo: Option<PathBuf>) -> BuildModel {
-    load_linked(root, cache_dir, maven_repo, &ide_core::settings::MavenSettings::default())
+    load_linked(
+        root,
+        cache_dir,
+        maven_repo,
+        &ide_core::settings::MavenSettings::default(),
+        &ide_core::settings::GradleSettings::default(),
+    )
 }
 
 /// Loads only linked Maven reactors, retaining an empty model so projects can be re-added.
@@ -53,31 +73,66 @@ pub fn load_linked(
     cache_dir: &Path,
     maven_repo: Option<PathBuf>,
     settings: &ide_core::settings::MavenSettings,
+    gradle_settings: &ide_core::settings::GradleSettings,
 ) -> BuildModel {
-    let maven = maven::is_maven_project(root).then(|| {
+    let maven = maven::has_projects(root, settings).then(|| {
         let profiles = sync::maven_profiles(cache_dir);
-        let mut m = maven::load_with(root, maven_repo.or_else(maven::default_local_repo), &profiles);
+        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
     });
-    let gradle = gradle::load(root).map(|mut g| {
-        sync::apply_gradle_cache(root, cache_dir, &mut g);
-        g
-    });
+    let gradle = gradle::load_linked(root, gradle_settings)
+        .into_iter()
+        .map(|mut g| {
+            sync::apply_gradle_cache(root, &gradle::cache_dir(cache_dir, &g.dir), &mut g);
+            g
+        })
+        .collect();
     BuildModel { maven, gradle }
 }
 
 /// Gradle project folders outside `root` as of the last sync (`includeFlat` siblings):
 /// extra content roots, as IDEA lists module roots beside the project folder.
 /// Reads only the sync's cached projects (no build script), so it is cheap enough for hot paths.
-pub fn gradle_external_roots(root: &Path, cache_dir: &Path) -> Vec<PathBuf> {
-    gradle::external_roots(root, sync::reported_gradle_projects(cache_dir).iter().map(|p| p.dir.as_str()))
+pub fn gradle_external_roots(
+    root: &Path,
+    cache_dir: &Path,
+    settings: &ide_core::settings::GradleSettings,
+) -> Vec<PathBuf> {
+    let builds = gradle::linked_dirs(root, settings);
+    let dirs: Vec<String> = builds
+        .iter()
+        .flat_map(|dir| {
+            std::iter::once(root.join(dir).to_string_lossy().into_owned()).chain(
+                sync::reported_gradle_projects(&gradle::cache_dir(cache_dir, dir))
+                    .iter()
+                    .map(|p| p.dir.clone())
+                    .collect::<Vec<_>>(),
+            )
+        })
+        .collect();
+    gradle::external_roots(root, dirs.iter().map(String::as_str))
 }
 
 /// Source, resource and build folders of the last Gradle sync, absolute.
-pub fn gradle_source_roots(cache_dir: &Path) -> Vec<(PathBuf, gradle::ReportedRoot)> {
-    gradle::reported_source_roots(&sync::reported_gradle_projects(cache_dir))
+pub fn gradle_source_roots(
+    root: &Path,
+    cache_dir: &Path,
+    settings: &ide_core::settings::GradleSettings,
+) -> Vec<(PathBuf, gradle::ReportedRoot)> {
+    let reported = gradle::linked_dirs(root, settings)
+        .iter()
+        .flat_map(|dir| sync::reported_gradle_projects(&gradle::cache_dir(cache_dir, dir)).as_ref().clone())
+        .collect::<Vec<_>>();
+    gradle::reported_source_roots(&reported)
 }
 
 /// A library the project depends on, as `groupId:artifactId:version`.
@@ -121,7 +176,7 @@ pub fn dependency_coordinates(root: &Path, model: &BuildModel) -> Vec<Dependency
             });
         }
     }
-    if let Some(g) = &model.gradle {
+    for g in &model.gradle {
         for script in g.projects.iter().filter_map(|p| p.build_file.as_ref()) {
             let Ok(text) = std::fs::read_to_string(root.join(script)) else { continue };
             out.extend(gradle::script_dependencies(&text).into_iter().map(|(group_id, artifact_id, version)| {
@@ -147,6 +202,26 @@ pub fn affects_build(rel: &Path) -> bool {
 mod tests {
     use super::*;
 
+    #[test]
+    fn external_linked_build_is_indexed_before_sync_and_disappears_when_unlinked() {
+        let temp = tempfile::tempdir().unwrap();
+        let root = temp.path().join("workspace");
+        let external = temp.path().join("external");
+        std::fs::create_dir(&root).unwrap();
+        std::fs::create_dir(&external).unwrap();
+        std::fs::write(external.join("settings.gradle"), "").unwrap();
+        let mut settings = ide_core::settings::GradleSettings {
+            linked_projects: Some(vec![external.to_string_lossy().into_owned()]),
+            ..Default::default()
+        };
+        assert_eq!(
+            gradle_external_roots(&root, &temp.path().join("cache"), &settings),
+            [dunce::canonicalize(&external).unwrap()]
+        );
+        settings.linked_projects = Some(vec![]);
+        assert!(gradle_external_roots(&root, &temp.path().join("cache"), &settings).is_empty());
+    }
+
     #[test]
     fn detects_build_systems_and_build_files() {
         let tmp = tempfile::tempdir().unwrap();
@@ -158,7 +233,7 @@ mod tests {
         std::fs::write(root.join("build.gradle"), "").unwrap();
         let m = load(&root, &cache, None);
         assert_eq!(m.maven.unwrap().projects[0].pom, "svc/pom.xml");
-        assert_eq!(m.gradle.unwrap().projects[0].path, ":");
+        assert_eq!(m.gradle[0].projects[0].path, ":");
         assert!(affects_build(Path::new("a/pom.xml")) && affects_build(Path::new("settings.gradle.kts")));
         assert!(!affects_build(Path::new("src/Main.java")));
     }
@@ -205,7 +280,7 @@ mod tests {
             ],
             ..Default::default()
         };
-        let gradle = gradle::load(root);
+        let gradle = gradle::load(root).into_iter().collect();
         let model = BuildModel { maven: Some(maven), gradle };
         let names: Vec<String> = dependency_coordinates(root, &model)
             .into_iter()
diff --git a/crates/ide-build/src/maven.rs b/crates/ide-build/src/maven.rs
index 12c8b14a8..5fd70ba67 100644
--- a/crates/ide-build/src/maven.rs
+++ b/crates/ide-build/src/maven.rs
@@ -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> {
@@ -1065,10 +1100,9 @@ pub fn load(root: &Path) -> MavenModel {
     load_with_repo(root, default_local_repo())
 }
 
-/// [`load`] with the chosen `profiles` (`-P` entries; `!id` deactivates): their modules,
-/// dependencies and properties are part of the model, those turned off are not.
-pub fn load_with_profiles(root: &Path, profiles: &[String]) -> MavenModel {
-    load_with(root, default_local_repo(), profiles)
+/// [`load`] with the POMs `settings` link (Add Maven Projects).
+pub fn load_linked(root: &Path, settings: &ide_core::settings::MavenSettings) -> MavenModel {
+    load_with_linked(root, default_local_repo(), &[], &settings.linked_projects)
 }
 
 pub(crate) fn load_with_repo(root: &Path, local_repo: Option<PathBuf>) -> MavenModel {
@@ -1090,11 +1124,53 @@ fn profile_choice(chosen: &[String], id: &str) -> Option<bool> {
 }
 
 pub(crate) fn load_with(root: &Path, local_repo: Option<PathBuf>, profiles: &[String]) -> MavenModel {
+    load_with_linked(root, local_repo, profiles, &[])
+}
+
+/// The POMs of `linked` (project-relative, from Settings) that exist inside `root`.
+fn linked_poms(root: &Path, linked: &[String]) -> Vec<PathBuf> {
+    let base = dunce::canonicalize(root).unwrap_or_else(|_| root.to_path_buf());
+    let mut out: Vec<PathBuf> = Vec::new();
+    for pom in linked {
+        let pom = normalized_pom(pom);
+        if pom.is_empty() || pom.starts_with("../") || pom == ".." {
+            continue;
+        }
+        let path = root.join(&pom);
+        let inside = dunce::canonicalize(&path).is_ok_and(|p| p.starts_with(&base));
+        if path.is_file() && inside && !out.contains(&path) {
+            out.push(path);
+        }
+    }
+    out
+}
+
+/// Whether `root` holds a Maven build or the settings link one inside it.
+pub fn has_projects(root: &Path, settings: &ide_core::settings::MavenSettings) -> bool {
+    is_maven_project(root) || !linked_poms(root, &settings.linked_projects).is_empty()
+}
+
+/// The model with the chosen `profiles` (`-P` entries; `!id` deactivates: their modules,
+/// dependencies and properties are part of the model, those turned off are not) and the
+/// `linked` POMs (Add Maven Projects): builds that no reactor lists, shown as independent
+/// top-level projects. A linked POM that turns out to be a module of the root reactor stays that module.
+pub fn load_with_linked(
+    root: &Path,
+    local_repo: Option<PathBuf>,
+    profiles: &[String],
+    linked: &[String],
+) -> MavenModel {
     let mut resolver = Resolver::new(local_repo, profiles);
     let mut model = MavenModel::default();
     let mut seen: HashSet<PathBuf> = HashSet::new();
-    // (pom, aggregated)
-    let mut stack: Vec<(PathBuf, bool)> = top_level_poms(root).into_iter().rev().map(|p| (p, false)).collect();
+    let mut tops = top_level_poms(root);
+    for pom in linked_poms(root, linked) {
+        if !tops.contains(&pom) {
+            tops.push(pom);
+        }
+    }
+    // (pom, aggregated); the root reactor and its modules come before linked POMs.
+    let mut stack: Vec<(PathBuf, bool)> = tops.into_iter().rev().map(|p| (p, false)).collect();
     while let Some((path, aggregated)) = stack.pop() {
         if model.projects.len() >= MAX_PROJECTS {
             break;
@@ -1216,7 +1292,7 @@ impl UnlinkedProjects {
         if settings.unlinked_projects.is_empty() {
             return Self::default();
         }
-        Self::from_model(&load(root), settings)
+        Self::from_model(&load_linked(root, settings), settings)
     }
 
     pub fn from_model(model: &MavenModel, settings: &ide_core::settings::MavenSettings) -> Self {
@@ -1495,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();
@@ -1733,6 +1840,49 @@ mod tests {
         assert!(model.projects.iter().all(|p| p.command == if cfg!(windows) { "mvn.cmd" } else { "mvn" }));
     }
 
+    /// Add Maven Projects: a POM inside the project that no reactor lists becomes an
+    /// independent top-level project; one the root reactor lists stays its module.
+    #[test]
+    fn linked_poms_outside_the_reactor_are_top_level_projects() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        write(
+            root,
+            "pom.xml",
+            "<project><groupId>demo</groupId><artifactId>main</artifactId><version>1.0</version><packaging>pom</packaging><modules><module>core</module></modules></project>",
+        );
+        write(
+            root,
+            "core/pom.xml",
+            "<project><groupId>demo</groupId><artifactId>core</artifactId><version>1.0</version></project>",
+        );
+        write(
+            root,
+            "stub/pom.xml",
+            "<project><groupId>demo</groupId><artifactId>stub</artifactId><version>1.0</version></project>",
+        );
+        let top = |m: &MavenModel| m.projects.iter().map(|p| (p.dir.clone(), p.aggregated)).collect::<Vec<_>>();
+
+        assert_eq!(top(&load_with_linked(root, None, &[], &[])), [("".into(), false), ("core".into(), true)]);
+        let linked: Vec<String> =
+            ["stub/pom.xml", "./core/pom.xml", "../outside/pom.xml", "missing/pom.xml"].map(String::from).into();
+        assert_eq!(
+            top(&load_with_linked(root, None, &[], &linked)),
+            [("".into(), false), ("core".into(), true), ("stub".into(), false)]
+        );
+
+        // Deeper than the folder search reaches: only the link makes it a Maven project.
+        let deep = tempfile::tempdir().unwrap();
+        write(deep.path(), "a/b/c/tool/pom.xml", "<project><artifactId>tool</artifactId></project>");
+        let settings = ide_core::settings::MavenSettings {
+            linked_projects: vec!["a/b/c/tool/pom.xml".into()],
+            ..Default::default()
+        };
+        assert!(!has_projects(deep.path(), &Default::default()));
+        assert!(has_projects(deep.path(), &settings));
+        assert_eq!(top(&load_linked(deep.path(), &settings)), [("a/b/c/tool".into(), false)]);
+    }
+
     #[test]
     fn chosen_profiles_bring_their_modules_and_dependencies() {
         let tmp = tempfile::tempdir().unwrap();
diff --git a/crates/ide-build/src/sync.rs b/crates/ide-build/src/sync.rs
index 1a2524407..b390b2cca 100644
--- a/crates/ide-build/src/sync.rs
+++ b/crates/ide-build/src/sync.rs
@@ -283,7 +283,12 @@ pub fn sync_maven(
     cancel: &CancellationToken,
     progress: &dyn Fn(SyncProgress),
 ) -> IdeResult<()> {
-    let mut model = maven::load_with_profiles(root, &options.profiles);
+    let mut model = maven::load_with_linked(
+        root,
+        maven::default_local_repo(),
+        &options.profiles,
+        &options.maven_settings.linked_projects,
+    );
     maven::UnlinkedProjects::from_model(&model, &options.maven_settings).filter(&mut model);
     std::fs::create_dir_all(cache_dir)?;
     let mut cache = MavenCache {
@@ -373,8 +378,25 @@ pub fn sync_gradle(
     cancel: &CancellationToken,
     progress: &dyn Fn(SyncProgress),
 ) -> IdeResult<()> {
-    let mut model = gradle::load(root).ok_or_else(|| IdeError::not_found("no Gradle build in this project"))?;
-    std::fs::create_dir_all(cache_dir)?;
+    let model = gradle::load(root).ok_or_else(|| IdeError::not_found("no Gradle build in this project"))?;
+    sync_gradle_model(root, cache_dir, &model, options, cancel, progress)
+}
+
+/// Syncs this exact linked build; another build's task paths and cache cannot interfere.
+pub fn sync_gradle_model(
+    root: &Path,
+    cache_dir: &Path,
+    model: &GradleModel,
+    options: &SyncOptions,
+    cancel: &CancellationToken,
+    progress: &dyn Fn(SyncProgress),
+) -> IdeResult<()> {
+    if cancel.is_cancelled() {
+        return Err(IdeError::cancelled());
+    }
+    let mut model = model.clone();
+    let cache_dir = gradle::cache_dir(cache_dir, &model.dir);
+    std::fs::create_dir_all(&cache_dir)?;
     let init_script = cache_dir.join("openidea-model.gradle");
     std::fs::write(&init_script, MODEL_INIT_SCRIPT)?;
     let mut args: Vec<String> = vec![
@@ -389,14 +411,24 @@ pub fn sync_gradle(
         args.push("--offline".into());
     }
     progress(SyncProgress { message: "Loading Gradle tasks".into(), fraction: None });
-    let out = run(
+    let out = match run(
         options.gradle_command.as_deref().unwrap_or(&model.command),
         &args,
         &root.join(&model.dir),
         &options.env,
         cancel,
         |_| {},
-    )?;
+    ) {
+        Ok(out) => out,
+        Err(_) if cancel.is_cancelled() => return Err(IdeError::cancelled()),
+        Err(error) if error.kind == ide_core::error::ErrorKind::Unavailable => {
+            Output { success: false, text: error.message }
+        }
+        Err(error) => return Err(error),
+    };
+    if cancel.is_cancelled() {
+        return Err(IdeError::cancelled());
+    }
     let projects = if out.success { parse_reported_projects(&out.text) } else { Vec::new() };
     // Hash the build files of the reported projects, or the model is stale right after the sync.
     gradle::merge_reported_projects(root, &mut model, &projects);
@@ -407,13 +439,128 @@ pub fn sync_gradle(
         tasks: if out.success { gradle::parse_tasks(&out.text) } else { Vec::new() },
         projects,
     };
-    write_cache(cache_dir, GRADLE_CACHE, &cache)
+    write_cache(&cache_dir, GRADLE_CACHE, &cache)
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    #[cfg(unix)]
+    #[test]
+    fn unavailable_gradle_launchers_are_cached_without_stopping_other_builds() {
+        use std::os::unix::fs::PermissionsExt;
+        let temp = tempfile::tempdir().unwrap();
+        let root = temp.path();
+        for dir in ["a", "b"] {
+            std::fs::create_dir(root.join(dir)).unwrap();
+            std::fs::write(root.join(dir).join("build.gradle"), "").unwrap();
+        }
+        let wrapper = root.join("b/gradlew");
+        std::fs::write(&wrapper, "#!/bin/sh\nprintf '%s\\n' 'Build tasks' '-----------' 'healthy - ok'\n").unwrap();
+        std::fs::set_permissions(&wrapper, std::fs::Permissions::from_mode(0o755)).unwrap();
+        let settings = ide_core::settings::GradleSettings {
+            linked_projects: Some(vec!["a".into(), "b".into()]),
+            ..Default::default()
+        };
+        let mut models = gradle::load_linked(root, &settings);
+        models[0].command = root.join("a/missing-gradlew").to_string_lossy().into_owned();
+        let cache = root.join("cache");
+        let run = |model: &GradleModel| {
+            sync_gradle_model(root, &cache, model, &SyncOptions::default(), &CancellationToken::new(), &|_| {})
+        };
+        for model in &models {
+            run(model).unwrap();
+        }
+        let loaded = crate::load_linked(root, &cache, None, &Default::default(), &settings);
+        assert!(loaded.gradle[0].sync_error.as_deref().unwrap().contains("cannot start"));
+        assert!(loaded.gradle[1].sync_error.is_none());
+        assert_eq!(loaded.gradle[1].projects[0].tasks[0].name, "healthy");
+        let bad_wrapper = root.join("a/gradlew");
+        std::fs::write(&bad_wrapper, "#!/bin/sh\nexit 0\n").unwrap();
+        std::fs::set_permissions(&bad_wrapper, std::fs::Permissions::from_mode(0o644)).unwrap();
+        models[0].command = bad_wrapper.to_string_lossy().into_owned();
+        run(&models[0]).unwrap();
+        let loaded = crate::load_linked(root, &cache, None, &Default::default(), &settings);
+        assert!(loaded.gradle[0].sync_error.as_deref().unwrap().contains("cannot start"));
+        assert!(loaded.gradle[1].sync_error.is_none());
+        let blocked_cache = root.join("blocked-cache");
+        std::fs::write(&blocked_cache, "a file cannot contain sync caches").unwrap();
+        assert!(
+            sync_gradle_model(
+                root,
+                &blocked_cache,
+                &models[0],
+                &SyncOptions::default(),
+                &CancellationToken::new(),
+                &|_| {}
+            )
+            .is_err()
+        );
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn independent_syncs_do_not_share_tasks_launchers_environments_or_failures() {
+        use std::os::unix::fs::PermissionsExt;
+        let temp = tempfile::tempdir().unwrap();
+        let root = temp.path();
+        for dir in ["a", "b"] {
+            let build = root.join(dir);
+            std::fs::create_dir_all(build.join("app")).unwrap();
+            std::fs::write(build.join("settings.gradle"), "include 'app'").unwrap();
+            std::fs::write(build.join("app/build.gradle"), "").unwrap();
+            let report = serde_json::json!({"path": ":app", "dir": build.join("app")});
+            let launcher = build.join("gradlew");
+            std::fs::write(
+                &launcher,
+                format!("#!/bin/sh\npwd > actual-cwd\nprintf '%s' \"$JAVA_HOME\" > actual-env\nprintf '%s\\n' '@openidea-model\t{report}' 'Build tasks' '-----------' 'app:custom{dir} - custom task'\n"),
+            ).unwrap();
+            std::fs::set_permissions(launcher, std::fs::Permissions::from_mode(0o755)).unwrap();
+        }
+        let settings = ide_core::settings::GradleSettings {
+            linked_projects: Some(vec!["a".into(), "b".into()]),
+            ..Default::default()
+        };
+        let cache = root.join("cache");
+        let models = gradle::load_linked(root, &settings);
+        for model in &models {
+            let options = SyncOptions {
+                env: BTreeMap::from([("JAVA_HOME".into(), format!("/jdk-{}", model.dir))]),
+                ..Default::default()
+            };
+            sync_gradle_model(root, &cache, model, &options, &CancellationToken::new(), &|_| {}).unwrap();
+            assert_eq!(
+                std::fs::read_to_string(root.join(&model.dir).join("actual-env")).unwrap(),
+                format!("/jdk-{}", model.dir)
+            );
+            assert_eq!(
+                std::fs::read_to_string(root.join(&model.dir).join("actual-cwd")).unwrap().trim(),
+                root.join(&model.dir).canonicalize().unwrap().to_string_lossy()
+            );
+        }
+        let load = || crate::load_linked(root, &cache, None, &Default::default(), &settings);
+        let model = load();
+        assert_eq!(model.gradle[0].projects[0].tasks[0].name, "customa");
+        assert_eq!(model.gradle[1].projects[0].tasks[0].name, "customb");
+        assert_ne!(gradle::cache_dir(&cache, "a"), gradle::cache_dir(&cache, "b"));
+        let before = std::fs::read(gradle::cache_dir(&cache, "a").join(GRADLE_CACHE)).unwrap();
+        std::fs::write(root.join("b/gradlew"), "#!/bin/sh\nprintf 'FAILURE: broken b\\n'\nexit 1\n").unwrap();
+        sync_gradle_model(root, &cache, &models[1], &SyncOptions::default(), &CancellationToken::new(), &|_| {})
+            .unwrap();
+        let model = load();
+        assert!(model.gradle[0].sync_error.is_none());
+        assert!(model.gradle[1].sync_error.is_some());
+        assert_eq!(std::fs::read(gradle::cache_dir(&cache, "a").join(GRADLE_CACHE)).unwrap(), before);
+        let cancel = CancellationToken::new();
+        cancel.cancel();
+        assert!(sync_gradle_model(root, &cache, &models[0], &SyncOptions::default(), &cancel, &|_| {}).is_err());
+        assert_eq!(std::fs::read(gradle::cache_dir(&cache, "a").join(GRADLE_CACHE)).unwrap(), before);
+        let unlinked = ide_core::settings::GradleSettings { linked_projects: Some(vec![]), ..Default::default() };
+        assert!(crate::load_linked(root, &cache, None, &Default::default(), &unlinked).gradle.is_empty());
+        assert!(crate::gradle_source_roots(root, &cache, &unlinked).is_empty());
+    }
+
     #[cfg(unix)]
     #[test]
     fn gradle_sync_uses_resolved_command_and_environment() {
@@ -601,7 +748,7 @@ mod tests {
         write(&projects);
         let first = reported_gradle_projects(&cache_dir);
         assert!(Arc::ptr_eq(&first, &reported_gradle_projects(&cache_dir)), "unchanged: not parsed again");
-        assert_eq!(crate::gradle_external_roots(&root, &cache_dir), [billing]);
+        assert_eq!(crate::gradle_external_roots(&root, &cache_dir, &Default::default()), [billing]);
         write(&projects[..1]);
         assert_eq!(reported_gradle_projects(&cache_dir).len(), 1, "a new sync is read");
         std::fs::remove_file(cache_dir.join(GRADLE_CACHE)).unwrap();
diff --git a/crates/ide-build/src/web.rs b/crates/ide-build/src/web.rs
index 9f25039ac..fbff22b77 100644
--- a/crates/ide-build/src/web.rs
+++ b/crates/ide-build/src/web.rs
@@ -26,12 +26,12 @@ pub fn artifacts(root: &Path, model: &BuildModel) -> Vec<WebArtifact> {
             });
         }
     }
-    if let Some(gradle) = &model.gradle {
+    for gradle in &model.gradle {
         for p in &gradle.projects {
             let script = p.build_file.as_ref().and_then(|f| fs::read_to_string(root.join(f)).ok()).unwrap_or_default();
             if p.tasks.iter().any(|t| t.name == "war") || crate::gradle::has_war_plugin(&script) {
                 out.push(WebArtifact {
-                    id: format!("gradle:{}", p.path),
+                    id: gradle_artifact_id(gradle, &p.path),
                     name: p.name.clone(),
                     module: p.dir.clone(),
                     tool: "gradle".into(),
@@ -42,6 +42,14 @@ pub fn artifacts(root: &Path, model: &BuildModel) -> Vec<WebArtifact> {
     out
 }
 
+fn gradle_artifact_id(build: &crate::GradleModel, path: &str) -> String {
+    if build.dir.is_empty() {
+        format!("gradle:{path}")
+    } else {
+        format!("gradle:{}", serde_json::to_string(&(&build.dir, path)).unwrap())
+    }
+}
+
 pub struct WebBuild {
     pub command: String,
     pub args: Vec<String>,
@@ -150,9 +158,14 @@ pub fn build(root: &Path, model: &BuildModel, id: &str, cache: &Path) -> IdeResu
             maven_project: Some((probe, output)),
         });
     }
-    if let Some(path) = id.strip_prefix("gradle:") {
-        let g = model.gradle.as_ref().ok_or_else(|| IdeError::invalid("Choose a Gradle WAR module"))?;
-        if !artifacts(root, model).iter().any(|a| a.id == id) {
+    if let Some(legacy_path) = id.strip_prefix("gradle:") {
+        let identity = serde_json::from_str::<(String, String)>(legacy_path).ok();
+        let (g, path) = match &identity {
+            Some((dir, path)) => (model.gradle.iter().find(|g| g.dir == *dir), path.as_str()),
+            None => (model.gradle.first(), legacy_path),
+        };
+        let g = g.ok_or_else(|| IdeError::invalid("Choose a Gradle WAR module"))?;
+        if !artifacts(root, model).iter().any(|a| a.id == gradle_artifact_id(g, path)) {
             return Err(IdeError::invalid("Choose a Gradle WAR module"));
         }
         let script = cache.join("war.init.gradle");
@@ -186,6 +199,28 @@ pub fn build(root: &Path, model: &BuildModel, id: &str, cache: &Path) -> IdeResu
 
 #[cfg(test)]
 mod tests {
+    #[test]
+    fn independent_war_modules_have_distinct_ids_and_build_in_their_own_directory() {
+        let temp = tempfile::tempdir().unwrap();
+        let root = temp.path();
+        for dir in ["a", "b"] {
+            std::fs::create_dir(root.join(dir)).unwrap();
+            std::fs::write(root.join(dir).join("build.gradle"), "plugins { id 'war' }").unwrap();
+        }
+        let settings = ide_core::settings::GradleSettings {
+            linked_projects: Some(vec!["a".into(), "b".into()]),
+            ..Default::default()
+        };
+        let model = crate::load_linked(root, &root.join("cache"), None, &Default::default(), &settings);
+        let artifacts = super::artifacts(root, &model);
+        assert_eq!(artifacts.len(), 2);
+        assert_ne!(artifacts[0].id, artifacts[1].id);
+        for (artifact, dir) in artifacts.iter().zip(["a", "b"]) {
+            let plan = super::build(root, &model, &artifact.id, &root.join(format!("cache/{dir}"))).unwrap();
+            assert_eq!(plan.cwd, dir);
+        }
+        assert_eq!(super::build(root, &model, "gradle::", &root.join("legacy")).unwrap().cwd, "a");
+    }
     use super::*;
     #[test]
     fn maven_war_modules_use_resolved_artifact_file() {
diff --git a/crates/ide-core/src/lib.rs b/crates/ide-core/src/lib.rs
index 023f9d729..7bbb35dad 100644
--- a/crates/ide-core/src/lib.rs
+++ b/crates/ide-core/src/lib.rs
@@ -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};
diff --git a/crates/ide-core/src/settings.rs b/crates/ide-core/src/settings.rs
index 4b41cfe75..6f65eff4c 100644
--- a/crates/ide-core/src/settings.rs
+++ b/crates/ide-core/src/settings.rs
@@ -828,6 +828,8 @@ pub struct JavaSettings {
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
 #[serde(default, rename_all = "camelCase")]
 pub struct GradleSettings {
+    /// Linked build directories; absent preserves automatic discovery, empty unlinks all builds.
+    pub linked_projects: Option<Vec<String>>,
     /// Empty = Project JDK; otherwise a JDK home.
     pub jvm: String,
     pub distribution: GradleDistribution,
@@ -864,6 +866,8 @@ pub enum GradleDistribution {
 pub struct MavenSettings {
     /// Project-relative root POMs removed from the Maven project model.
     pub unlinked_projects: Vec<String>,
+    /// Project-relative POMs outside the root reactor added as independent top-level projects.
+    pub linked_projects: Vec<String>,
     /// Maven home (or its `mvn` executable); empty = the project's `mvnw`, else `mvn` on `PATH`.
     pub home: String,
     /// User `settings.xml` (`-s`); empty = `~/.m2/settings.xml`.
@@ -1124,6 +1128,16 @@ mod maven_linkage_tests {
 mod gradle_settings_tests {
     use super::*;
 
+    #[test]
+    fn absent_and_explicitly_empty_gradle_links_remain_distinct() {
+        let automatic: GradleSettings = serde_json::from_str("{}").unwrap();
+        let unlinked: GradleSettings = serde_json::from_str(r#"{"linkedProjects":[]}"#).unwrap();
+        assert_eq!(automatic.linked_projects, None);
+        assert_eq!(unlinked.linked_projects, Some(vec![]));
+        let restored: GradleSettings = serde_json::from_str(&serde_json::to_string(&unlinked).unwrap()).unwrap();
+        assert_eq!(restored.linked_projects, Some(vec![]));
+    }
+
     #[test]
     fn defaults_and_round_trip() {
         let old: JavaSettings = serde_json::from_str(r#"{"jdk":"/jdk"}"#).unwrap();
@@ -1136,6 +1150,7 @@ mod gradle_settings_tests {
                 home: "/gradle".into(),
                 user_home: "/cache/gradle".into(),
                 run_using: GradleRunUsing::Ide,
+                linked_projects: Some(vec!["backend".into(), "../shared".into()]),
             };
             let restored: Settings = serde_json::from_str(&serde_json::to_string(&settings).unwrap()).unwrap();
             assert_eq!(restored.languages.java.gradle, settings.languages.java.gradle);
diff --git a/crates/ide-core/src/wsl.rs b/crates/ide-core/src/wsl.rs
new file mode 100644
index 000000000..985280c4b
--- /dev/null
+++ b/crates/ide-core/src/wsl.rs
@@ -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"));
+    }
+}
diff --git a/crates/ide-dap/src/lib.rs b/crates/ide-dap/src/lib.rs
index f2790ad54..5d3012377 100644
--- a/crates/ide-dap/src/lib.rs
+++ b/crates/ide-dap/src/lib.rs
@@ -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",
diff --git a/crates/ide-dap/src/tests.rs b/crates/ide-dap/src/tests.rs
index 1e5647b7c..e1efd7101 100644
--- a/crates/ide-dap/src/tests.rs
+++ b/crates/ide-dap/src/tests.rs
@@ -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();
+}
diff --git a/crates/ide-db/src/clickhouse.rs b/crates/ide-db/src/clickhouse.rs
index 34e869dce..9d04f9c7d 100644
--- a/crates/ide-db/src/clickhouse.rs
+++ b/crates/ide-db/src/clickhouse.rs
@@ -150,6 +150,7 @@ impl ClickhousePool {
         self.0.client.read().clone().ok_or_else(|| IdeError::new(ErrorKind::Io, "ClickHouse connection is closed"))
     }
 
+    /// `max_rows`: the rows the server may send (the skipped ones included).
     fn request(&self, client: &Client, query_id: &str, max_rows: usize, initialized: bool) -> RequestBuilder {
         let mut request = client
             .post(self.0.endpoint.clone())
@@ -177,6 +178,17 @@ impl ClickhousePool {
     }
 
     pub async fn execute(&self, sql: &str, max_rows: usize, cancel: &CancellationToken) -> IdeResult<QueryResult> {
+        self.execute_from(sql, 0, max_rows, cancel).await
+    }
+
+    /// [`execute`](Self::execute), reading past the first `skip` rows without parsing or keeping them.
+    pub async fn execute_from(
+        &self,
+        sql: &str,
+        skip: usize,
+        max_rows: usize,
+        cancel: &CancellationToken,
+    ) -> IdeResult<QueryResult> {
         if transaction_statement(sql) {
             return Err(transaction_error());
         }
@@ -188,7 +200,7 @@ impl ClickhousePool {
         };
         let client = self.client()?;
         let query_id = uuid::Uuid::new_v4().to_string();
-        let request = self.request(&client, &query_id, max_rows, *session).body(sql.to_owned());
+        let request = self.request(&client, &query_id, skip.saturating_add(max_rows), *session).body(sql.to_owned());
         let started = Instant::now();
         let fetch = async {
             let mut response = request.send().await.map_err(http_error)?;
@@ -216,7 +228,7 @@ impl ClickhousePool {
                 }
                 (Vec::new(), Vec::new(), false)
             } else {
-                let mut reader = RowReader::new(max_rows);
+                let mut reader = RowReader::new(skip, max_rows);
                 while let Some(chunk) = response.chunk().await.map_err(http_error)? {
                     reader.push(&chunk)?;
                 }
@@ -309,11 +321,13 @@ impl ClickhousePool {
 
 type DecodedResult = (Vec<ResultColumn>, Vec<Vec<Option<String>>>, bool);
 
-/// Decodes a streamed [`FORMAT`] body. Keeps the first `max_rows` rows; later rows only set
-/// `has_more` and are read past unparsed, so a grid limit bounds memory however large the
-/// block `result_overflow_mode=break` lets the server send. A line that is not a JSON array
+/// Decodes a streamed [`FORMAT`] body. Reads past the first `skip` rows unparsed (a later
+/// page), then keeps `max_rows` rows; later rows only set `has_more` and are read past
+/// unparsed, so a grid limit bounds memory however large the block
+/// `result_overflow_mode=break` lets the server send. A line that is not a JSON array
 /// starts the exception ClickHouse writes when a query fails mid-stream.
 struct RowReader {
+    skip: usize,
     max_rows: usize,
     pending: Vec<u8>,
     names: Option<Vec<String>>,
@@ -324,8 +338,17 @@ struct RowReader {
 }
 
 impl RowReader {
-    fn new(max_rows: usize) -> Self {
-        Self { max_rows, pending: Vec::new(), names: None, types: None, rows: Vec::new(), more: false, exception: None }
+    fn new(skip: usize, max_rows: usize) -> Self {
+        Self {
+            skip,
+            max_rows,
+            pending: Vec::new(),
+            names: None,
+            types: None,
+            rows: Vec::new(),
+            more: false,
+            exception: None,
+        }
     }
 
     fn push(&mut self, chunk: &[u8]) -> IdeResult<()> {
@@ -356,9 +379,15 @@ impl RowReader {
             self.exception = Some(format!("{}\n", String::from_utf8_lossy(line)));
             return Ok(());
         }
-        if self.names.is_some() && self.types.is_some() && self.rows.len() >= self.max_rows {
-            self.more = true;
-            return Ok(());
+        if self.names.is_some() && self.types.is_some() {
+            if self.skip > 0 {
+                self.skip -= 1;
+                return Ok(());
+            }
+            if self.rows.len() >= self.max_rows {
+                self.more = true;
+                return Ok(());
+            }
         }
         let Ok(values) = serde_json::from_slice::<Vec<Box<serde_json::value::RawValue>>>(text) else {
             self.exception = Some(format!("{}\n", String::from_utf8_lossy(line)));
@@ -547,7 +576,11 @@ mod tests {
     }
 
     fn decode(body: &[u8], max_rows: usize, chunk: usize) -> IdeResult<DecodedResult> {
-        let mut reader = RowReader::new(max_rows);
+        decode_from(body, 0, max_rows, chunk)
+    }
+
+    fn decode_from(body: &[u8], skip: usize, max_rows: usize, chunk: usize) -> IdeResult<DecodedResult> {
+        let mut reader = RowReader::new(skip, max_rows);
         for part in body.chunks(chunk) {
             reader.push(part)?;
         }
@@ -586,6 +619,18 @@ mod tests {
         assert!(decode(b"[\"x\"]\n[\"UInt8\"]\n[1, 2]\n", 1, 64).is_err());
     }
 
+    #[test]
+    fn a_later_page_skips_rows_without_keeping_them() {
+        let body = b"[\"n\"]\n[\"UInt8\"]\n[1]\n[2]\n[3]\n[4]\n[5]\n";
+        let page = |skip, max| {
+            let (_, rows, more) = decode_from(body, skip, max, 3).unwrap();
+            (rows.into_iter().map(|r| r[0].clone().unwrap()).collect::<Vec<_>>(), more)
+        };
+        assert_eq!(page(2, 2), (vec!["3".to_owned(), "4".to_owned()], true));
+        assert_eq!(page(4, 2), (vec!["5".to_owned()], false));
+        assert_eq!(page(9, 2), (Vec::<String>::new(), false));
+    }
+
     #[test]
     fn rows_past_the_limit_are_skipped_but_a_later_exception_still_fails() {
         let mut body = String::from("[\"n\"]\n[\"UInt64\"]\n");
diff --git a/crates/ide-db/src/conn.rs b/crates/ide-db/src/conn.rs
index 94bd01348..020dc0c6c 100644
--- a/crates/ide-db/src/conn.rs
+++ b/crates/ide-db/src/conn.rs
@@ -337,10 +337,13 @@ fn result_columns<R: Row>(row: &R) -> Vec<ResultColumn> {
         .collect()
 }
 
-/// Streams the results of `$sql` on executor `$exec`, keeping at most `$max` rows
-/// with their cells read as `$mode`.
+/// Streams the results of `$sql` on executor `$exec`, reading past the first `$skip`
+/// rows without decoding them, then keeping at most `$max` rows with their cells read as `$mode`.
 macro_rules! fetch {
-    ($exec:expr, $sql:expr, $max:expr, $mode:expr) => {{
+    ($exec:expr, $sql:expr, $max:expr, $mode:expr) => {
+        fetch!($exec, $sql, 0usize, $max, $mode)
+    };
+    ($exec:expr, $sql:expr, $skip:expr, $max:expr, $mode:expr) => {{
         use futures::StreamExt;
         let mut stream = sqlx::raw_sql(sqlx::AssertSqlSafe($sql.to_owned())).fetch_many($exec);
         let mut columns: Vec<ResultColumn> = Vec::new();
@@ -349,6 +352,7 @@ macro_rules! fetch {
         let mut has_more = false;
         let mut failure = None;
         let mut first: Option<Instant> = None;
+        let mut to_skip: usize = $skip;
         while let Some(item) = stream.next().await {
             first.get_or_insert_with(Instant::now);
             match item {
@@ -357,6 +361,10 @@ macro_rules! fetch {
                     if columns.is_empty() {
                         columns = result_columns(&row);
                     }
+                    if to_skip > 0 {
+                        to_skip -= 1;
+                        continue;
+                    }
                     if rows.len() >= $max {
                         has_more = true;
                         break;
@@ -386,7 +394,8 @@ async fn mssql_command(conn: &mut MssqlClient, sql: &str) -> IdeResult<()> {
     Ok(())
 }
 
-async fn mssql_fetch(conn: &mut MssqlClient, sql: &str, max: usize) -> IdeResult<Fetched> {
+/// Like [`fetch!`] for SQL Server: the first `skip` rows are read past without decoding.
+async fn mssql_fetch(conn: &mut MssqlClient, sql: &str, skip: usize, max: usize) -> IdeResult<Fetched> {
     let mut stream = conn.simple_query(sql).await.map_err(mssql_err)?;
     let first = Some(Instant::now());
     let columns = stream
@@ -399,8 +408,13 @@ async fn mssql_fetch(conn: &mut MssqlClient, sql: &str, max: usize) -> IdeResult
         .collect();
     let mut rows = Vec::new();
     let mut has_more = false;
+    let mut to_skip = skip;
     while let Some(item) = stream.next().await {
         if let tiberius::QueryItem::Row(row) = item.map_err(mssql_err)? {
+            if to_skip > 0 {
+                to_skip -= 1;
+                continue;
+            }
             if rows.len() >= max {
                 has_more = true;
                 break;
@@ -734,7 +748,7 @@ impl Pool {
         let fetched: IdeResult<Fetched> = match self {
             Pool::SqlServer(p) => {
                 let mut conn = p.get_owned().await.map_err(mssql_pool_err)?;
-                mssql_fetch(&mut conn, sql, max).await
+                mssql_fetch(&mut conn, sql, 0, max).await
             }
             _ => with_pool!(self, p => fetch!(p, sql, max, Cells::Text)),
         };
@@ -744,11 +758,23 @@ impl Pool {
     /// Runs one statement and keeps at most `max_rows` rows. Cancelling stops
     /// the statement on the server (PostgreSQL, MySQL) and drops the connection.
     pub async fn execute(&self, sql: &str, max_rows: usize, cancel: &CancellationToken) -> IdeResult<QueryResult> {
+        self.execute_from(sql, 0, max_rows, cancel).await
+    }
+
+    /// [`execute`](Self::execute), reading past the first `skip` rows without keeping them
+    /// (a later page of a result: only that page is decoded and returned).
+    pub async fn execute_from(
+        &self,
+        sql: &str,
+        skip: usize,
+        max_rows: usize,
+        cancel: &CancellationToken,
+    ) -> IdeResult<QueryResult> {
         if let Pool::Clickhouse(p) = self {
-            return p.execute(sql, max_rows, cancel).await;
+            return p.execute_from(sql, skip, max_rows, cancel).await;
         }
         let mut conn = Held::acquire(self).await?;
-        let r = conn.execute(self, sql, max_rows, cancel).await;
+        let r = conn.execute_from(self, sql, skip, max_rows, cancel).await;
         if cancel.is_cancelled() {
             conn.discard().await;
             return Err(IdeError::cancelled());
@@ -874,9 +900,22 @@ impl Held {
         sql: &str,
         max_rows: usize,
         cancel: &CancellationToken,
+    ) -> IdeResult<QueryResult> {
+        self.execute_from(pool, sql, 0, max_rows, cancel).await
+    }
+
+    /// [`execute`](Self::execute), reading past the first `skip` rows without keeping them
+    /// (see [`Pool::execute_from`]).
+    pub async fn execute_from(
+        &mut self,
+        pool: &Pool,
+        sql: &str,
+        skip: usize,
+        max_rows: usize,
+        cancel: &CancellationToken,
     ) -> IdeResult<QueryResult> {
         if let Held::Clickhouse(c) = self {
-            return c.execute(sql, max_rows, cancel).await;
+            return c.execute_from(sql, skip, max_rows, cancel).await;
         }
         let started = Instant::now();
         // `$id`: the query naming the server process, `$kill`: how another connection stops it.
@@ -887,7 +926,7 @@ impl Held {
                     None => None,
                 };
                 let r = tokio::select! {
-                    r = async { fetch!(&mut **$conn, sql, max_rows, Cells::Display) } => r,
+                    r = async { fetch!(&mut **$conn, sql, skip, max_rows, Cells::Display) } => r,
                     () = cancel.cancelled() => Err(IdeError::cancelled()),
                 };
                 if cancel.is_cancelled() {
@@ -916,7 +955,7 @@ impl Held {
             Held::SqlServer(c) => {
                 // Tiberius has no attention/cancel API; stop reading and discard the connection.
                 tokio::select! {
-                    r = mssql_fetch(c, sql, max_rows) => r?,
+                    r = mssql_fetch(c, sql, skip, max_rows) => r?,
                     () = cancel.cancelled() => return Err(IdeError::cancelled()),
                 }
             }
diff --git a/crates/ide-db/src/lib.rs b/crates/ide-db/src/lib.rs
index 71545ecbb..b549395d2 100644
--- a/crates/ide-db/src/lib.rs
+++ b/crates/ide-db/src/lib.rs
@@ -1009,7 +1009,20 @@ impl DbManager {
         max_rows: usize,
         cancel: &CancellationToken,
     ) -> IdeResult<QueryResult> {
-        let r = self.run(id, statement, max_rows, cancel).await;
+        self.execute_from(id, statement, 0, max_rows, cancel).await
+    }
+
+    /// [`execute`](Self::execute), reading past the first `skip` rows without keeping
+    /// them: a later page of a result, where only that page is decoded and returned.
+    pub async fn execute_from(
+        &self,
+        id: &str,
+        statement: &str,
+        skip: usize,
+        max_rows: usize,
+        cancel: &CancellationToken,
+    ) -> IdeResult<QueryResult> {
+        let r = self.run(id, statement, skip, max_rows, cancel).await;
         let ran = match &r {
             Ok(_) => true,
             Err(e) => !matches!(e.kind, ErrorKind::Cancelled | ErrorKind::PermissionDenied),
@@ -1044,7 +1057,7 @@ impl DbManager {
     /// The execution plan of `statement` (explained, not run).
     pub async fn explain(&self, id: &str, statement: &str, cancel: &CancellationToken) -> IdeResult<Vec<PlanNode>> {
         let driver = self.pool(id).await?.driver();
-        let result = self.run(id, &plan::explain_statement(driver, statement), MAX_META_ROWS, cancel).await?;
+        let result = self.run(id, &plan::explain_statement(driver, statement), 0, MAX_META_ROWS, cancel).await?;
         plan::parse(driver, &result)
     }
 
@@ -1052,13 +1065,14 @@ impl DbManager {
         &self,
         id: &str,
         statement: &str,
+        skip: usize,
         max_rows: usize,
         cancel: &CancellationToken,
     ) -> IdeResult<QueryResult> {
         let pool = self.pool(id).await?;
         let session = self.sessions.lock().get(id).cloned();
         let Some(session) = session else {
-            return pool.execute(statement, max_rows, cancel).await;
+            return pool.execute_from(statement, skip, max_rows, cancel).await;
         };
         if pool.driver() == DbDriver::Clickhouse {
             return Err(IdeError::invalid("ClickHouse manual transactions are unsupported"));
@@ -1070,7 +1084,7 @@ impl DbManager {
             *held = Some(conn);
         }
         let conn = held.as_mut().expect("opened above");
-        let r = conn.execute(&pool, statement, max_rows, cancel).await;
+        let r = conn.execute_from(&pool, statement, skip, max_rows, cancel).await;
         if cancel.is_cancelled() {
             // The server rolls the transaction back with the connection.
             held.take().expect("opened above").discard().await;
diff --git a/crates/ide-db/tests/sqlite.rs b/crates/ide-db/tests/sqlite.rs
index b800cd154..06bf741a0 100644
--- a/crates/ide-db/tests/sqlite.rs
+++ b/crates/ide-db/tests/sqlite.rs
@@ -1,7 +1,9 @@
 //! Introspection, queries and table edits against a real SQLite file.
 
 use ide_core::{CancellationToken, IdeResult};
-use ide_db::{CellValue, DataSource, DbDriver, DbManager, DbOptions, DbProperty, DbRowEdit, DbTableKind, SortKey};
+use ide_db::{
+    CellValue, DataSource, DbDriver, DbManager, DbOptions, DbProperty, DbRowEdit, DbTableKind, QueryResult, SortKey,
+};
 
 async fn setup() -> (tempfile::TempDir, DbManager) {
     let tmp = tempfile::tempdir().unwrap();
@@ -123,6 +125,28 @@ async fn queries_with_limits_nulls_and_blobs() -> IdeResult<()> {
     Ok(())
 }
 
+#[tokio::test]
+async fn a_later_page_returns_only_its_rows() -> IdeResult<()> {
+    let (_tmp, db) = setup().await;
+    let c = CancellationToken::new();
+    let sql = "SELECT id FROM users ORDER BY id";
+    let ids = |r: &QueryResult| r.rows.iter().map(|row| row[0].clone().unwrap()).collect::<Vec<_>>();
+
+    let second = db.execute_from("s1", sql, 1, 1, &c).await?;
+    assert_eq!(ids(&second), vec!["2"]);
+    assert!(second.has_more);
+    assert_eq!(second.columns.len(), 1);
+
+    let last = db.execute_from("s1", sql, 2, 5, &c).await?;
+    assert_eq!(ids(&last), vec!["3"]);
+    assert!(!last.has_more);
+
+    let past = db.execute_from("s1", sql, 9, 5, &c).await?;
+    assert!(past.rows.is_empty() && !past.has_more);
+    assert_eq!(past.columns.len(), 1, "columns of a page past the end come from the prepared statement");
+    Ok(())
+}
+
 #[tokio::test]
 async fn pages_sorts_filters_and_edits_in_a_transaction() -> IdeResult<()> {
     let (_tmp, db) = setup().await;
diff --git a/crates/ide-extension/src/capability.rs b/crates/ide-extension/src/capability.rs
index bf68d5a35..a02c7193f 100644
--- a/crates/ide-extension/src/capability.rs
+++ b/crates/ide-extension/src/capability.rs
@@ -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"),
diff --git a/crates/ide-extension/src/manifest.rs b/crates/ide-extension/src/manifest.rs
index d079cff2d..aaeeabf67 100644
--- a/crates/ide-extension/src/manifest.rs
+++ b/crates/ide-extension/src/manifest.rs
@@ -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.
diff --git a/crates/ide-host/src/lib.rs b/crates/ide-host/src/lib.rs
index 2685d7bf1..70fcfb9b4 100644
--- a/crates/ide-host/src/lib.rs
+++ b/crates/ide-host/src/lib.rs
@@ -86,6 +86,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 +137,7 @@ impl Host {
             requests: Default::default(),
             project_requests: RwLock::default(),
             closing: Default::default(),
+            open_locks: Default::default(),
         };
         host.apply_proxy();
         host
@@ -401,6 +404,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);
     }
diff --git a/crates/ide-host/src/notebook.rs b/crates/ide-host/src/notebook.rs
index fb5d65cb1..413bb3c92 100644
--- a/crates/ide-host/src/notebook.rs
+++ b/crates/ide-host/src/notebook.rs
@@ -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();
diff --git a/crates/ide-host/src/ops/agent.rs b/crates/ide-host/src/ops/agent.rs
index 9662dc079..3a30a7b73 100644
--- a/crates/ide-host/src/ops/agent.rs
+++ b/crates/ide-host/src/ops/agent.rs
@@ -8,8 +8,11 @@ use ide_agent::{
     AgentChange, AgentCommand, AgentEntry, AgentEvent, AgentProbe, AgentPrompt, AgentProvider, AgentQueued, AgentTask,
     NewAgentTask,
 };
-use ide_core::{IdeError, IdeResult, IpcPath, RequestId};
+use ide_core::error::ErrorKind;
+use ide_core::{IdeError, IdeEvent, IdeResult, IpcPath, RequestId, SharedSink, TaskId};
 use ide_tools::InstallEvent;
+use std::collections::HashSet;
+use std::sync::{LazyLock, Mutex};
 
 /// Streams the project's agent events to this window; returns every task.
 pub fn subscribe(host: &Host, window: &str, on_event: Emit<AgentEvent>) -> IdeResult<Vec<AgentTask>> {
@@ -58,7 +61,39 @@ pub async fn registry_list(host: &Host, _window: &str, request: RequestId) -> Id
     let result =
         tokio::task::spawn_blocking(move || ide_agent::registry::list(&paths, &cancel)).await.map_err(join_err);
     host.end_request(request);
-    result?
+    let mut registry = result??;
+    let installing = installing();
+    for agent in &mut registry.agents {
+        agent.installing = installing.contains(&agent.id);
+    }
+    Ok(registry)
+}
+
+/// Registry installs in progress, by agent id. An install outlives the Settings page
+/// that started it, so a second one of the same agent is refused rather than racing it
+/// for the same folder.
+static INSTALLING: LazyLock<Mutex<HashSet<String>>> = LazyLock::new(Mutex::default);
+
+fn installing() -> std::sync::MutexGuard<'static, HashSet<String>> {
+    INSTALLING.lock().unwrap_or_else(|e| e.into_inner())
+}
+
+/// Marks agent `id` as installing until dropped.
+struct Installing(String);
+
+impl Installing {
+    fn begin(id: &str) -> IdeResult<Self> {
+        if !installing().insert(id.to_owned()) {
+            return Err(IdeError::new(ErrorKind::AlreadyExists, format!("{id} is already being installed")));
+        }
+        Ok(Self(id.to_owned()))
+    }
+}
+
+impl Drop for Installing {
+    fn drop(&mut self) {
+        installing().remove(&self.0);
+    }
 }
 
 /// Installs the registry's current version of agent `id` (also to update it), streaming
@@ -72,11 +107,43 @@ pub async fn registry_install(
     on_event: Channel<InstallEvent>,
 ) -> IdeResult<()> {
     let paths = registry_paths(host);
+    let installing = Installing::begin(&id)?;
     let cancel = host.begin_request(request);
+    // Also a background task of every project window, so it stays visible and can be
+    // stopped there once the Settings page is closed.
+    let task = TaskId::next();
+    let title = format!("Installing {id}");
+    let sinks: Vec<SharedSink> = host.projects().iter().map(|p| p.sink.clone()).collect();
+    let report = move |message: Option<String>, fraction: Option<f32>, done: bool| {
+        for sink in &sinks {
+            sink.emit(IdeEvent::Task {
+                id: task,
+                title: title.clone(),
+                message: message.clone(),
+                fraction,
+                done,
+                cancellable: !done,
+            });
+        }
+    };
     let result = tokio::task::spawn_blocking(move || {
-        ide_agent::registry::install(&paths, &id, &cancel, &|e| {
+        let _installing = installing;
+        let _cancel = ide_core::task::on_cancel(task, {
+            let cancel = cancel.clone();
+            move || cancel.cancel()
+        });
+        report(None, None, false);
+        let result = ide_agent::registry::install(&paths, &id, &cancel, &|e| {
+            match &e {
+                InstallEvent::Line { text } => report(Some(text.clone()), None, false),
+                InstallEvent::Progress { fraction, message } => {
+                    report(Some(message.clone()), fraction.map(|f| f as f32), false)
+                }
+            }
             let _ = on_event.send(e);
-        })
+        });
+        report(None, Some(1.0), true);
+        result
     })
     .await
     .map_err(join_err);
@@ -263,6 +330,20 @@ fn validate_project_root(root: &std::path::Path, requested: Option<&std::path::P
 #[cfg(test)]
 mod tests {
     use super::*;
+
+    #[test]
+    fn an_agent_installs_once_at_a_time() {
+        let first = Installing::begin("test-agent").unwrap();
+        assert!(installing().contains("test-agent"));
+        let again = Installing::begin("test-agent").err().unwrap();
+        assert_eq!(again.kind, ErrorKind::AlreadyExists);
+        let other = Installing::begin("test-other-agent").unwrap();
+        drop(first);
+        assert!(!installing().contains("test-agent"));
+        drop(Installing::begin("test-agent").unwrap());
+        drop(other);
+    }
+
     #[test]
     fn agent_roots_are_exact_window_or_workspace_members() {
         let tmp = tempfile::tempdir().unwrap();
diff --git a/crates/ide-host/src/ops/build.rs b/crates/ide-host/src/ops/build.rs
index 15337380c..074cbcad5 100644
--- a/crates/ide-host/src/ops/build.rs
+++ b/crates/ide-host/src/ops/build.rs
@@ -32,6 +32,7 @@ pub fn load(root: &Path, cache: &Path, settings: &Settings) -> BuildModel {
         cache,
         ide_sdk::apply::maven_local_repository(root, settings),
         &settings.languages.java.maven,
+        &settings.languages.java.gradle,
     );
     let jdk = ide_sdk::apply::project_jdk(root, settings);
     if let Some(m) = &mut model.maven {
@@ -45,7 +46,7 @@ pub fn load(root: &Path, cache: &Path, settings: &Settings) -> BuildModel {
             p.options = options.clone();
         }
     }
-    if let Some(g) = &mut model.gradle {
+    for g in &mut model.gradle {
         g.env = ide_sdk::apply::gradle_env(root, settings, java_env(jdk.as_ref(), g.java_version));
         g.command = ide_sdk::apply::gradle_command(root, &root.join(&g.dir), settings).to_string_lossy().into_owned();
     }
@@ -65,11 +66,12 @@ pub fn load(root: &Path, cache: &Path, settings: &Settings) -> BuildModel {
         let hint = m.projects.iter().find_map(|p| missing(p.java_version));
         explain(&mut m.sync_error, hint);
     }
-    if let Some(g) = &mut model.gradle
-        && g.sync_error.is_some()
-    {
-        let hint = if settings.languages.java.gradle.jvm.trim().is_empty() { missing(g.java_version) } else { None };
-        explain(&mut g.sync_error, hint);
+    for g in &mut model.gradle {
+        if g.sync_error.is_some() {
+            let hint =
+                if settings.languages.java.gradle.jvm.trim().is_empty() { missing(g.java_version) } else { None };
+            explain(&mut g.sync_error, hint);
+        }
     }
     model
 }
@@ -94,9 +96,89 @@ pub async fn build_model(host: &Host, window: &str) -> IdeResult<BuildModel> {
     tokio::task::spawn_blocking(move || load(&root, &cache, &settings)).await.map_err(join_err)
 }
 
+fn linked_gradle_paths(
+    root: &Path,
+    settings: &ide_core::settings::GradleSettings,
+    paths: &[String],
+    link: bool,
+) -> IdeResult<Vec<String>> {
+    let existing = settings
+        .linked_projects
+        .clone()
+        .unwrap_or_else(|| ide_build::gradle::load_linked(root, settings).into_iter().map(|g| g.dir).collect());
+    let mut linked = Vec::new();
+    for path in existing {
+        let normalized = ide_build::gradle::normalize_linked_projects(root, std::slice::from_ref(&path))
+            .unwrap_or_else(|_| vec![path]);
+        for path in normalized {
+            if !linked.contains(&path) {
+                linked.push(path);
+            }
+        }
+    }
+    if link {
+        let directories: Vec<String> = paths
+            .iter()
+            .map(|path| {
+                let path = root.join(path);
+                let is_script = path.file_name().and_then(|n| n.to_str()).is_some_and(|name| {
+                    ide_build::gradle::SETTINGS_FILES.contains(&name) || ide_build::gradle::BUILD_FILES.contains(&name)
+                });
+                if is_script && path.is_file() {
+                    path.parent().unwrap_or(root).to_string_lossy().into_owned()
+                } else {
+                    path.to_string_lossy().into_owned()
+                }
+            })
+            .collect();
+        for path in ide_build::gradle::normalize_linked_projects(root, &directories)? {
+            if !linked.contains(&path) {
+                linked.push(path);
+            }
+        }
+    } else {
+        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)
+}
+
+async fn set_gradle_projects(host: &Host, window: &str, paths: Vec<String>, link: bool) -> IdeResult<BuildModel> {
+    host.require_trust(window)?;
+    let project = host.project(window)?;
+    tokio::task::spawn_blocking(move || {
+        if ide_workspace::workspace::Workspace::load(&project.root)?.is_some() {
+            return Err(IdeError::invalid("Open a workspace member as a project to link Gradle builds"));
+        }
+        let linked =
+            linked_gradle_paths(&project.root, &project.settings.effective().languages.java.gradle, &paths, link)?;
+        let key = "languages.java.gradle.linkedProjects";
+        let settings =
+            project.settings.set(ide_workspace::settings::SettingsScope::Project, key, serde_json::json!(linked))?;
+        project.refresh_index_scope();
+        project.lsp.reconfigure_soon();
+        project.sink.emit(IdeEvent::SettingsChanged { key: key.into() });
+        project.sink.emit(IdeEvent::ProjectRootsChanged { root: project.root.clone().into() });
+        Ok::<BuildModel, IdeError>(load(&project.root, &project.build_cache_dir(), &settings))
+    })
+    .await
+    .map_err(join_err)?
+}
+
+/// Links independent builds without changing their Gradle scripts.
+pub async fn gradle_link_projects(host: &Host, window: &str, paths: Vec<String>) -> IdeResult<BuildModel> {
+    set_gradle_projects(host, window, paths, true).await
+}
+
+/// Stops importing the selected independent builds; files and saved run configurations stay intact.
+pub async fn gradle_unlink_projects(host: &Host, window: &str, paths: Vec<String>) -> IdeResult<BuildModel> {
+    set_gradle_projects(host, window, paths, false).await
+}
+
 /// Runs Maven (`help:effective-pom dependency:tree`) or Gradle (`tasks --all`) in the
 /// background, reporting progress on `on_progress`; cancellable with `cancel_request(request)`.
 /// Returns the refreshed model; a failed build is reported in its `syncError`.
+#[allow(clippy::too_many_arguments)]
 pub async fn build_sync(
     host: &Host,
     window: &str,
@@ -104,6 +186,7 @@ pub async fn build_sync(
     request: RequestId,
     offline: bool,
     profiles: Vec<String>,
+    build_dir: Option<String>,
     on_progress: Channel<SyncProgress>,
 ) -> IdeResult<BuildModel> {
     host.require_trust(window)?;
@@ -122,6 +205,8 @@ pub async fn build_sync(
         project.sink.emit(ide_core::IdeEvent::ProjectRootsChanged { root: project.root.clone().into() });
     }
     let token = host.begin_project_request(window, request);
+    let completion_token = token.clone();
+    let original_links = settings.languages.java.gradle.linked_projects.clone();
     let result = tokio::task::spawn_blocking(move || {
         let current = load(&root, &cache, &settings);
         let env = match tool {
@@ -131,7 +216,7 @@ pub async fn build_sync(
                 .and_then(|m| m.projects.iter().find(|p| !p.env.is_empty()))
                 .map(|p| p.env.clone())
                 .unwrap_or_default(),
-            BuildTool::Gradle => current.gradle.as_ref().map(|g| g.env.clone()).unwrap_or_default(),
+            BuildTool::Gradle => BTreeMap::new(),
         };
         let options = SyncOptions {
             offline,
@@ -140,14 +225,31 @@ pub async fn build_sync(
             maven_command: ide_sdk::apply::maven_command(&root, &settings).map(|p| p.to_string_lossy().into_owned()),
             maven_options: ide_sdk::apply::maven_options(&root, &settings),
             maven_settings: settings.languages.java.maven.clone(),
-            gradle_command: current.gradle.as_ref().map(|g| g.command.clone()),
+            gradle_command: None,
         };
         let progress = |p: SyncProgress| {
             let _ = on_progress.send(p);
         };
         match tool {
             BuildTool::Maven => ide_build::sync_maven(&root, &cache, &options, &token, &progress)?,
-            BuildTool::Gradle => ide_build::sync_gradle(&root, &cache, &options, &token, &progress)?,
+            BuildTool::Gradle => {
+                if let Some(dir) = &build_dir
+                    && !current.gradle.iter().any(|g| &g.dir == dir)
+                {
+                    return Err(IdeError::not_found("Gradle project is no longer linked"));
+                }
+                for g in current.gradle.iter().filter(|g| build_dir.as_ref().is_none_or(|dir| dir == &g.dir)) {
+                    if token.is_cancelled() {
+                        return Err(IdeError::cancelled());
+                    }
+                    let options =
+                        SyncOptions { env: g.env.clone(), gradle_command: Some(g.command.clone()), ..options.clone() };
+                    ide_build::sync_gradle_model(&root, &cache, g, &options, &token, &progress)?;
+                }
+                if token.is_cancelled() {
+                    return Err(IdeError::cancelled());
+                }
+            }
         }
         Ok::<BuildModel, IdeError>(load(&root, &cache, &settings))
     })
@@ -155,6 +257,18 @@ pub async fn build_sync(
     .map_err(join_err);
     host.end_request(request);
     let model = result??;
+    if completion_token.is_cancelled() {
+        return Err(IdeError::cancelled());
+    }
+    if tool == BuildTool::Gradle && original_links != project.settings.effective().languages.java.gradle.linked_projects
+    {
+        // A late sync must not re-import a build that was unlinked while it ran.
+        return tokio::task::spawn_blocking(move || {
+            load(&project.root, &project.build_cache_dir(), &project.settings.effective())
+        })
+        .await
+        .map_err(join_err);
+    }
     if tool == BuildTool::Gradle {
         // The sync may report project folders outside the project (`includeFlat`): index and list them.
         project.refresh_index_scope();
@@ -247,20 +361,26 @@ pub async fn gradle_dependencies(
     configuration: String,
     offline: bool,
     request: RequestId,
+    build_dir: Option<String>,
 ) -> IdeResult<Vec<ide_build::GradleDependency>> {
     host.require_trust(window)?;
     let project = host.project(window)?;
     let (root, cache, settings) = (project.root.clone(), project.build_cache_dir(), project.settings.effective());
     let token = host.begin_project_request(window, request);
     let result = tokio::task::spawn_blocking(move || {
-        let gradle = load(&root, &cache, &settings).gradle;
+        let model = load(&root, &cache, &settings);
+        let gradle = model
+            .gradle
+            .iter()
+            .find(|g| build_dir.as_ref().is_none_or(|dir| &g.dir == dir))
+            .ok_or_else(|| IdeError::not_found("Gradle project is no longer linked"))?;
         let options = SyncOptions {
             offline,
-            env: gradle.as_ref().map(|g| g.env.clone()).unwrap_or_default(),
-            gradle_command: gradle.as_ref().map(|g| g.command.clone()),
+            env: gradle.env.clone(),
+            gradle_command: Some(gradle.command.clone()),
             ..Default::default()
         };
-        ide_build::gradle_dependencies(&root, &options, &gradle_path, &configuration, &token)
+        ide_build::gradle_dependencies(&root, gradle, &options, &gradle_path, &configuration, &token)
     })
     .await
     .map_err(join_err);
@@ -382,6 +502,11 @@ pub async fn build_run(
 /// Commands of this module the remote server answers.
 pub(crate) fn register(d: &mut Dispatcher) {
     d.add("build_model", |c| async move { build_model(&c.host, &c.window).await });
+    d.add("gradle_link_projects", |c| async move { gradle_link_projects(&c.host, &c.window, c.arg("paths")?).await });
+    d.add(
+        "gradle_unlink_projects",
+        |c| async move { gradle_unlink_projects(&c.host, &c.window, c.arg("paths")?).await },
+    );
     d.add("build_sync", |c| async move {
         build_sync(
             &c.host,
@@ -390,6 +515,7 @@ pub(crate) fn register(d: &mut Dispatcher) {
             c.arg("request")?,
             c.arg("offline")?,
             c.arg("profiles")?,
+            c.arg("buildDir")?,
             c.sender("onProgress")?,
         )
         .await
@@ -405,6 +531,7 @@ pub(crate) fn register(d: &mut Dispatcher) {
             c.arg("configuration")?,
             c.arg("offline")?,
             c.arg("request")?,
+            c.arg("buildDir")?,
         )
         .await
     });
@@ -432,6 +559,48 @@ pub(crate) fn register(d: &mut Dispatcher) {
 mod gradle_settings_tests {
     use super::*;
 
+    #[test]
+    fn linking_retains_the_implicit_build_and_unlinking_all_stays_empty() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = dunce::canonicalize(tmp.path()).unwrap();
+        for name in ["a", "b"] {
+            std::fs::create_dir(root.join(name)).unwrap();
+            std::fs::write(root.join(name).join("settings.gradle"), format!("rootProject.name = '{name}'")).unwrap();
+        }
+        let mut settings = ide_core::settings::GradleSettings::default();
+        let linked = linked_gradle_paths(&root, &settings, &["b/settings.gradle".into()], true).unwrap();
+        assert_eq!(linked, ["a", "b"]);
+        settings.linked_projects = Some(linked);
+        assert_eq!(linked_gradle_paths(&root, &settings, &["b".into()], true).unwrap(), ["a", "b"]);
+        assert!(linked_gradle_paths(&root, &settings, &["missing".into()], true).is_err());
+        settings.linked_projects = Some(vec!["./a".into(), root.join("b").to_string_lossy().into_owned()]);
+        settings.linked_projects = Some(linked_gradle_paths(&root, &settings, &["a".into()], false).unwrap());
+        assert_eq!(settings.linked_projects.as_ref().unwrap(), &["b"]);
+        settings.linked_projects = Some(linked_gradle_paths(&root, &settings, &["b".into()], false).unwrap());
+        assert!(ide_build::gradle::load_linked(&root, &settings).is_empty());
+        assert!(root.join("a/settings.gradle").is_file());
+        assert!(root.join("b/settings.gradle").is_file());
+    }
+
+    #[test]
+    fn settings_resolve_each_linked_builds_own_wrapper() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = dunce::canonicalize(tmp.path()).unwrap();
+        let mut settings = Settings::default();
+        settings.languages.java.gradle.linked_projects = Some(vec!["a".into(), "b".into()]);
+        let executable = if cfg!(windows) { "gradlew.bat" } else { "gradlew" };
+        for dir in ["a", "b"] {
+            std::fs::create_dir(root.join(dir)).unwrap();
+            std::fs::write(root.join(dir).join("build.gradle"), "plugins { id 'java' }").unwrap();
+            std::fs::write(root.join(dir).join(executable), "").unwrap();
+        }
+        let model = load(&root, &root.join("cache"), &settings);
+        assert_eq!(model.gradle.len(), 2);
+        for g in model.gradle {
+            assert_eq!(g.command, root.join(&g.dir).join(executable).to_string_lossy());
+        }
+    }
+
     #[test]
     fn model_for_sync_tasks_and_compile_uses_gradle_settings() {
         let tmp = tempfile::tempdir().unwrap();
@@ -440,13 +609,13 @@ mod gradle_settings_tests {
         let wrapper = root.join(if cfg!(windows) { "gradlew.bat" } else { "gradlew" });
         std::fs::write(&wrapper, "").unwrap();
         let mut settings = Settings::default();
-        let default = load(root, &root.join("cache"), &settings).gradle.unwrap();
+        let default = load(root, &root.join("cache"), &settings).gradle.remove(0);
         assert_eq!(default.command, wrapper.to_string_lossy());
         settings.languages.java.gradle.jvm = "jdk21".into();
         settings.languages.java.gradle.user_home = "user-home".into();
         settings.languages.java.gradle.distribution = ide_core::settings::GradleDistribution::Local;
         settings.languages.java.gradle.home = "gradle-install".into();
-        let model = load(root, &root.join("cache"), &settings).gradle.unwrap();
+        let model = load(root, &root.join("cache"), &settings).gradle.remove(0);
         assert_eq!(
             model.command,
             root.join("gradle-install")
diff --git a/crates/ide-host/src/ops/db.rs b/crates/ide-host/src/ops/db.rs
index 102bf2742..079542f26 100644
--- a/crates/ide-host/src/ops/db.rs
+++ b/crates/ide-host/src/ops/db.rs
@@ -123,13 +123,14 @@ pub(crate) fn register(d: &mut Dispatcher) {
         statements(&c.host, &c.window, &id, &text, from, to)
     });
     d.add("db_execute", |c| async move {
-        let (request, id, statements, max_rows) = (
+        let (request, id, statements, skip, max_rows) = (
             c.arg::<RequestId>("request")?,
             c.arg::<String>("id")?,
             c.arg::<Vec<SqlStatement>>("statements")?,
+            c.arg::<Option<u32>>("skip")?.unwrap_or(0),
             c.arg::<u32>("maxRows")?,
         );
-        execute(&c.host, &c.window, request, &id, statements, max_rows).await
+        execute(&c.host, &c.window, request, &id, statements, skip, max_rows).await
     });
     d.add("db_table_page", |c| async move {
         let (request, id, schema, table) = (
@@ -325,20 +326,22 @@ pub fn statements(host: &Host, window: &str, id: &str, text: &str, from: u32, to
 }
 
 /// Runs `statements` in order on data source `id`, stopping at the first
-/// error. Cancel with `cancel_request(request)`.
+/// error. Each result reads past its first `skip` rows (a later page) and keeps
+/// `max_rows`. Cancel with `cancel_request(request)`.
 pub async fn execute(
     host: &Host,
     window: &str,
     request: RequestId,
     id: &str,
     statements: Vec<SqlStatement>,
+    skip: u32,
     max_rows: u32,
 ) -> IdeResult<Vec<StatementOutcome>> {
     let db = host.project(window)?.db.clone();
     let cancel = host.begin_request(request);
     let mut out = Vec::new();
     for statement in statements {
-        match db.execute(id, &statement.text, max_rows.max(1) as usize, &cancel).await {
+        match db.execute_from(id, &statement.text, skip as usize, max_rows.max(1) as usize, &cancel).await {
             Ok(result) => out.push(StatementOutcome { statement, result: Some(result), error: None }),
             Err(e) if e.kind == ide_core::error::ErrorKind::Cancelled => {
                 host.end_request(request);
diff --git a/crates/ide-host/src/ops/debug.rs b/crates/ide-host/src/ops/debug.rs
index 0d17a593b..827223544 100644
--- a/crates/ide-host/src/ops/debug.rs
+++ b/crates/ide-host/src/ops/debug.rs
@@ -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,
diff --git a/crates/ide-host/src/ops/project.rs b/crates/ide-host/src/ops/project.rs
index 459a96d51..8d71234c8 100644
--- a/crates/ide-host/src/ops/project.rs
+++ b/crates/ide-host/src/ops/project.rs
@@ -196,7 +196,9 @@ pub fn set_settings(
     }
     let roots_changed = key == "projectStructure"
         || key.starts_with("projectStructure.")
-        || "languages.java.maven.unlinkedProjects".starts_with(key);
+        || "languages.java.maven.unlinkedProjects".starts_with(key)
+        || "languages.java.maven.linkedProjects".starts_with(key)
+        || "languages.java.gradle.linkedProjects".starts_with(key);
     // Content roots and excludes (files.exclude, ignored names, excluded folders) reach the
     // index and the watchers without reopening the project (the rescan runs in the background).
     if roots_changed || key == "files" || key.starts_with("files.") {
diff --git a/crates/ide-host/src/ops/routes.rs b/crates/ide-host/src/ops/routes.rs
index cbf2965e0..3d6f2e1ce 100644
--- a/crates/ide-host/src/ops/routes.rs
+++ b/crates/ide-host/src/ops/routes.rs
@@ -20,7 +20,7 @@ const MAX_FILE_BYTES: u64 = 4 << 20;
 #[derive(Clone, Debug, Serialize, Deserialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct RouteSource {
-    pub path: String,
+    pub path: ide_core::IpcPath,
     pub text: String,
 }
 
@@ -51,7 +51,7 @@ pub(crate) fn sources_in(root: &Path, excludes: &[String]) -> Vec<RouteSource> {
             return;
         }
         bytes.fetch_add(text.len(), Ordering::Relaxed);
-        found.push(RouteSource { path: path.to_string_lossy().into_owned(), text });
+        found.push(RouteSource { path: path.to_path_buf().into(), text });
     });
     let mut files = found.into_inner().unwrap_or_default();
     files.sort_by(|a, b| a.path.cmp(&b.path));
@@ -116,7 +116,7 @@ mod tests {
         std::fs::write(tmp.path().join("src/Notes.txt"), "@GetMapping(\"/a\")").unwrap();
         let files = sources_in(tmp.path(), &[]);
         assert_eq!(files.len(), 1, "{:?}", files.iter().map(|f| &f.path).collect::<Vec<_>>());
-        assert!(Path::new(&files[0].path).ends_with("src/Ctl.java"), "{}", files[0].path);
+        assert!(files[0].path.ends_with("src/Ctl.java"), "{:?}", files[0].path);
         assert!(files[0].text.contains("@GetMapping"));
     }
 
@@ -129,6 +129,6 @@ mod tests {
         std::fs::write(tmp.path().join("build/B.java"), "@RequestMapping(\"/b\")").unwrap();
         let files = sources_in(tmp.path(), &["build/**".to_owned()]);
         assert_eq!(files.len(), 1, "{:?}", files.iter().map(|f| &f.path).collect::<Vec<_>>());
-        assert!(Path::new(&files[0].path).ends_with("module/src/A.java"), "{}", files[0].path);
+        assert!(files[0].path.ends_with("module/src/A.java"), "{:?}", files[0].path);
     }
 }
diff --git a/crates/ide-host/src/ops/sdk.rs b/crates/ide-host/src/ops/sdk.rs
index 535426d8a..702c35c2d 100644
--- a/crates/ide-host/src/ops/sdk.rs
+++ b/crates/ide-host/src/ops/sdk.rs
@@ -23,8 +23,26 @@ pub struct LocatedTools {
 /// Installed interpreters / toolchains of `kind`; project-local ones first.
 pub async fn sdk_detect(host: &Host, window: &str, kind: SdkKind) -> IdeResult<Vec<Sdk>> {
     host.require_trust(window)?;
-    let root = host.project(window).ok().map(|p| p.root.clone());
-    tokio::task::spawn_blocking(move || ide_sdk::detect(kind, root.as_deref())).await.map_err(join_err)
+    let project = host.project(window).ok();
+    let root = project.as_ref().map(|p| p.root.clone());
+    // The interpreter the project uses is a choice even where detection doesn't look (a
+    // virtualenv in a subfolder, one picked by path), so it shows by name and version.
+    let current = match (&project, kind) {
+        (Some(p), SdkKind::Python) => ide_sdk::apply::python_interpreter(&p.root, &p.settings.effective()),
+        _ => None,
+    };
+    tokio::task::spawn_blocking(move || {
+        let mut sdks = ide_sdk::detect(kind, root.as_deref());
+        if let Some(path) = current
+            && !sdks.iter().any(|s| *s.path == *path)
+            && let Some(sdk) = ide_sdk::python_interpreter_sdk(&path, root.as_deref())
+        {
+            sdks.push(sdk);
+        }
+        sdks
+    })
+    .await
+    .map_err(join_err)
 }
 
 /// The interpreter the project uses: the configured one, else its virtualenv.
diff --git a/crates/ide-host/src/ops/vcs/commands.rs b/crates/ide-host/src/ops/vcs/commands.rs
index 4075dd9dc..9dc44f29a 100644
--- a/crates/ide-host/src/ops/vcs/commands.rs
+++ b/crates/ide-host/src/ops/vcs/commands.rs
@@ -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,
@@ -492,7 +470,7 @@ pub async fn vcs_add_to_ignore(
     window: &str,
     paths: Vec<PathBuf>,
     destination: IgnoreDestination,
-) -> IdeResult<Vec<String>> {
+) -> IdeResult<Vec<ide_core::IpcPath>> {
     host.require_trust(window)?;
     let project = host.project(window)?;
     blocking(move || {
@@ -509,7 +487,7 @@ pub async fn vcs_add_to_ignore(
             watcher.reload_ignore_rules();
         }
         project.sink.emit(ide_core::IdeEvent::VcsChanged { root: project.root.clone().into() });
-        result.map(|files| files.into_iter().map(|p| p.to_string_lossy().into_owned()).collect())
+        result.map(|files| files.into_iter().map(Into::into).collect())
     })
     .await
 }
@@ -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
     });
diff --git a/crates/ide-host/src/plugins/api.rs b/crates/ide-host/src/plugins/api.rs
index 1b1c997eb..a09e61a1e 100644
--- a/crates/ide-host/src/plugins/api.rs
+++ b/crates/ide-host/src/plugins/api.rs
@@ -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:ghp_token@github.com/o/r.git", "https://github.com/o/r.git"),
+            ("https://token@gitlab.com/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"),
+            ("git@github.com:o/r.git", "git@github.com: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");
+    }
+}
diff --git a/crates/ide-host/src/plugins/intellij.rs b/crates/ide-host/src/plugins/intellij.rs
index 3ccc62fa5..3fda40fac 100644
--- a/crates/ide-host/src/plugins/intellij.rs
+++ b/crates/ide-host/src/plugins/intellij.rs
@@ -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");
diff --git a/crates/ide-host/src/plugins/remote_host.rs b/crates/ide-host/src/plugins/remote_host.rs
index 9c8690239..7b845a84d 100644
--- a/crates/ide-host/src/plugins/remote_host.rs
+++ b/crates/ide-host/src/plugins/remote_host.rs
@@ -115,6 +115,8 @@ pub fn forwarded(event: &PluginEvent) -> bool {
             | PluginEvent::ViewMessage { .. }
             | PluginEvent::OpenTerminal { .. }
             | PluginEvent::OpenLocation { .. }
+            | PluginEvent::CopyToClipboard { .. }
+            | PluginEvent::OpenUrl { .. }
     )
 }
 
diff --git a/crates/ide-host/src/plugins/types.rs b/crates/ide-host/src/plugins/types.rs
index bd5e197ce..53c737e54 100644
--- a/crates/ide-host/src/plugins/types.rs
+++ b/crates/ide-host/src/plugins/types.rs
@@ -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
diff --git a/crates/ide-host/src/project.rs b/crates/ide-host/src/project.rs
index af9ebb4a4..0bdd984c9 100644
--- a/crates/ide-host/src/project.rs
+++ b/crates/ide-host/src/project.rs
@@ -77,6 +77,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
@@ -230,6 +232,11 @@ impl Host {
                 if cfg.name == "jdtls" {
                     let (excluded_poms, build_files) = jdtls_maven_import(root, &effective);
                     ide_sdk::apply::configure_maven_import(cfg, root, &excluded_poms, build_files.as_deref());
+                    ide_sdk::apply::configure_gradle_import(
+                        cfg,
+                        effective.languages.java.gradle.linked_projects.as_deref(),
+                        build_files.as_deref(),
+                    );
                 }
             }));
         }
@@ -564,6 +571,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
         {
@@ -876,8 +885,14 @@ impl Project {
 
     /// Effective source / test / resource / excluded roots (detected + Project Structure marks).
     pub fn roots(&self) -> ProjectRoots {
-        let detected = with_gradle_roots(&self.root, &self.build_cache_dir(), &self.detected_roots.read());
-        linked_roots(&self.root, &self.settings.effective(), &detected)
+        let settings = self.settings.effective();
+        let detected = with_gradle_roots(
+            &self.root,
+            &self.build_cache_dir(),
+            &settings.languages.java.gradle,
+            &self.detected_roots.read(),
+        );
+        linked_roots(&self.root, &settings, &detected)
     }
 
     /// Where the Maven / Gradle tool windows cache what the build tools reported.
@@ -1078,7 +1093,7 @@ fn content_roots(settings: &ide_core::settings::Settings, root: &Path, build_cac
     }
     let mut out: Vec<PathBuf> = Vec::new();
     let user = settings.project_structure.content_roots.iter().map(|r| PathBuf::from(r.trim()));
-    for p in user.chain(ide_build::gradle_external_roots(root, build_cache)) {
+    for p in user.chain(ide_build::gradle_external_roots(root, build_cache, &settings.languages.java.gradle)) {
         if p.is_absolute() && p.is_dir() && !p.starts_with(root) && !out.contains(&p) {
             out.push(p);
         }
@@ -1182,31 +1197,93 @@ pub(crate) fn jdtls_maven_import(
     settings: &ide_core::settings::Settings,
 ) -> (Vec<PathBuf>, Option<Vec<String>>) {
     let maven = &settings.languages.java.maven;
-    if maven.unlinked_projects.is_empty() {
+    let gradle = &settings.languages.java.gradle;
+    if maven.unlinked_projects.is_empty() && gradle.linked_projects.is_none() {
         return (Vec::new(), None);
     }
-    let model = ide_build::maven::load(root);
+    let model = ide_build::maven::load_linked(root, maven);
     let unlinked = ide_build::maven::UnlinkedProjects::from_model(&model, maven);
     let excluded = unlinked.poms().map(PathBuf::from).collect();
-    let build_files = unlinked.import_poms(&model).map(|poms| {
-        let gradle = ide_build::gradle::load(root).and_then(|g| {
+    let poms = unlinked.import_poms(&model).or_else(|| {
+        gradle.linked_projects.as_ref().map(|_| {
+            model
+                .projects
+                .iter()
+                .filter(|p| !p.aggregated && !unlinked.contains(&p.pom))
+                .map(|p| p.pom.clone())
+                .collect()
+        })
+    });
+    let build_files = poms.map(|poms| {
+        let gradle = ide_build::gradle::load_linked(root, gradle).into_iter().filter_map(|g| {
             let dir = root.join(&g.dir);
             let names = ide_build::gradle::SETTINGS_FILES.iter().chain(ide_build::gradle::BUILD_FILES);
             names.map(|n| dir.join(n)).find(|f| f.is_file())
         });
-        poms.iter().map(|pom| root.join(pom)).chain(gradle).map(|f| ide_lsp::path_to_uri_string(&f)).collect()
+        let eclipse = if settings.languages.java.gradle.linked_projects.is_some() {
+            independent_eclipse_projects(root)
+        } else {
+            Vec::new()
+        };
+        poms.iter()
+            .map(|pom| root.join(pom))
+            .chain(gradle)
+            .chain(eclipse)
+            .map(|f| ide_lsp::path_to_uri_string(&f))
+            .collect()
     });
     (excluded, build_files)
 }
 
+/// Explicit Gradle imports must retain Eclipse projects without re-importing generated build metadata.
+fn independent_eclipse_projects(root: &Path) -> Vec<PathBuf> {
+    let managed = |dir: &Path| {
+        std::iter::once("pom.xml")
+            .chain(ide_build::gradle::SETTINGS_FILES.iter().copied())
+            .chain(ide_build::gradle::BUILD_FILES.iter().copied())
+            .any(|name| dir.join(name).is_file())
+    };
+    if managed(root) {
+        return Vec::new();
+    }
+    let walker = ignore::WalkBuilder::new(root)
+        .standard_filters(false)
+        .filter_entry(move |entry| {
+            if !entry.file_type().is_some_and(|kind| kind.is_dir()) {
+                return false;
+            }
+            if entry.depth() > 0
+                && (entry.file_name().to_string_lossy().starts_with('.')
+                    || matches!(
+                        entry.file_name().to_str(),
+                        Some("node_modules" | "target" | "build" | "dist" | "out" | "bin" | "vendor")
+                    )
+                    || entry.path().parent().is_some_and(|parent| parent.join(".project").is_file()))
+            {
+                return false;
+            }
+            !managed(entry.path())
+        })
+        .build();
+    let mut projects: Vec<_> =
+        walker.flatten().map(|entry| entry.path().join(".project")).filter(|path| path.is_file()).collect();
+    projects.sort();
+    projects
+}
+
 /// The detected roots with the last Gradle sync's source sets first: Gradle evaluated what
 /// static detection guesses. Folders outside the project keep their absolute path, which
 /// `normalize` turns into the same form the UI compares (`Users/me/svc/src/main/java`).
-fn with_gradle_roots(root: &Path, build_cache: &Path, detected: &[SourceFolder]) -> Vec<SourceFolder> {
+fn with_gradle_roots(
+    root: &Path,
+    build_cache: &Path,
+    settings: &ide_core::settings::GradleSettings,
+    detected: &[SourceFolder],
+) -> Vec<SourceFolder> {
     use ide_build::gradle::ReportedRoot;
     use ide_workspace::roots::RootKind;
     let mut out: Vec<SourceFolder> = Vec::new();
-    for (dir, kind) in ide_build::gradle_source_roots(build_cache) {
+    for (dir, kind) in ide_build::gradle_source_roots(root, build_cache, settings) {
         if !dir.is_dir() {
             continue;
         }
@@ -1376,6 +1453,37 @@ pub fn apply_git_executable(settings: &ide_core::settings::Settings) {
 
 #[cfg(test)]
 mod maven_linkage_tests {
+    #[test]
+    fn explicit_gradle_links_preserve_independent_eclipse_projects() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        for dir in
+            ["linked", "unlinked", "eclipse", "nested/eclipse", "unlinked/subproject", "maven", "build/generated"]
+        {
+            std::fs::create_dir_all(root.join(dir)).unwrap();
+            std::fs::write(root.join(dir).join(".project"), "<projectDescription/>").unwrap();
+        }
+        for dir in ["linked", "unlinked"] {
+            std::fs::write(root.join(dir).join("settings.gradle"), "").unwrap();
+        }
+        std::fs::write(root.join("maven/pom.xml"), "<project/>").unwrap();
+        let mut settings = ide_core::settings::Settings::default();
+        settings.languages.java.gradle.linked_projects = Some(vec!["linked".into()]);
+        let (_, files) = super::jdtls_maven_import(root, &settings);
+        let files = files.unwrap();
+        let uri = |path: &str| ide_lsp::path_to_uri_string(&root.join(path));
+        assert!(files.contains(&uri("linked/settings.gradle")));
+        assert!(files.contains(&uri("maven/pom.xml")));
+        assert!(files.contains(&uri("eclipse/.project")));
+        assert!(files.contains(&uri("nested/eclipse/.project")));
+        assert!(!files.iter().any(|path| path.contains("unlinked") || path.contains("build/generated")));
+        assert!(!files.contains(&uri("linked/.project")));
+        assert!(!files.contains(&uri("maven/.project")));
+        settings.languages.java.gradle.linked_projects = Some(vec![]);
+        let (_, files) = super::jdtls_maven_import(root, &settings);
+        assert_eq!(files.unwrap(), [uri("maven/pom.xml"), uri("eclipse/.project"), uri("nested/eclipse/.project")]);
+    }
+
     #[test]
     fn jdtls_imports_the_linked_modules_and_the_gradle_build_once_a_reactor_module_is_unlinked() {
         let tmp = tempfile::tempdir().unwrap();
@@ -1473,7 +1581,8 @@ mod gradle_roots_tests {
         std::fs::write(cache.join("gradle.json"), json.to_string()).unwrap();
         let guessed = SourceFolder { path: "src/it/java".into(), kind: RootKind::Source, detected_from: None };
         let other = SourceFolder { path: "web".into(), kind: RootKind::Source, detected_from: None };
-        let out = with_gradle_roots(&root, &cache, &[guessed, other.clone()]);
+        std::fs::write(root.join("build.gradle"), "").unwrap();
+        let out = with_gradle_roots(&root, &cache, &Default::default(), &[guessed, other.clone()]);
         let abs = |p: PathBuf| ide_workspace::roots::normalize(&s(p));
         let got: Vec<(String, RootKind)> = out.iter().map(|f| (f.path.clone(), f.kind)).collect();
         assert_eq!(
diff --git a/crates/ide-host/src/trust.rs b/crates/ide-host/src/trust.rs
index 2ddd6859d..ca3194b50 100644
--- a/crates/ide-host/src/trust.rs
+++ b/crates/ide-host/src/trust.rs
@@ -217,6 +217,8 @@ pub fn restricted_command_allowed(cmd: &str) -> bool {
             | "lsp_resend_diagnostics"
             | "recent_projects"
             | "remove_recent_project"
+            | "recent_project_groups"
+            | "set_recent_project_groups"
             | "open_project"
             | "close_project"
             | "project_current"
@@ -249,6 +251,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"
@@ -312,7 +316,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"
diff --git a/crates/ide-host/tests/gradle_linkage.rs b/crates/ide-host/tests/gradle_linkage.rs
new file mode 100644
index 000000000..d53c41f4a
--- /dev/null
+++ b/crates/ide-host/tests/gradle_linkage.rs
@@ -0,0 +1,49 @@
+use ide_core::NullSink;
+use ide_host::{Host, HostConfig, ops};
+use std::sync::Arc;
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn links_are_validated_persisted_and_unlinked_without_removing_files() {
+    let temp = tempfile::tempdir().unwrap();
+    let base = dunce::canonicalize(temp.path()).unwrap();
+    let root = base.join("workspace");
+    for dir in [root.join("a"), root.join("b"), base.join("external")] {
+        std::fs::create_dir_all(&dir).unwrap();
+        std::fs::write(dir.join("settings.gradle"), "rootProject.name = 'same-name'").unwrap();
+    }
+    let config = base.join("config");
+    let host = Host::new(HostConfig {
+        config_dir: config.clone(),
+        data_dir: base.join("data"),
+        local_data_dir: base.join("local"),
+        languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
+        syntax: Arc::default(),
+        sink_for: Box::new(|_| Arc::new(NullSink)),
+        owner: |window| window,
+        runtime: tokio::runtime::Handle::current(),
+        project_environment: false,
+    });
+    host.open_project("main", &root).unwrap();
+    assert!(ops::build::gradle_link_projects(&host, "main", vec!["b".into()]).await.is_err());
+    host.set_project_trust(&root, true, false).await.unwrap();
+    let model = ops::build::gradle_link_projects(&host, "main", vec!["b/settings.gradle".into()]).await.unwrap();
+    assert_eq!(model.gradle.iter().map(|g| g.dir.as_str()).collect::<Vec<_>>(), ["a", "b"]);
+    let saved =
+        || ide_workspace::SettingsStore::load(&config, Some(&root)).effective().languages.java.gradle.linked_projects;
+    assert_eq!(saved(), Some(vec!["a".into(), "b".into()]));
+    assert!(ops::build::gradle_link_projects(&host, "main", vec!["missing".into()]).await.is_err());
+    assert_eq!(saved(), Some(vec!["a".into(), "b".into()]));
+    let outside = base.join("external").to_string_lossy().into_owned();
+    let model = ops::build::gradle_link_projects(&host, "main", vec![outside.clone()]).await.unwrap();
+    assert_eq!(model.gradle.len(), 3);
+    let model = ops::build::gradle_unlink_projects(&host, "main", vec!["a".into(), "b".into(), outside]).await.unwrap();
+    assert!(model.gradle.is_empty());
+    assert_eq!(saved(), Some(vec![]));
+    for dir in [root.join("a"), root.join("b"), base.join("external")] {
+        assert!(dir.join("settings.gradle").is_file());
+    }
+    let model = ops::build::gradle_link_projects(&host, "main", vec!["b".into()]).await.unwrap();
+    assert_eq!(model.gradle.len(), 1);
+    assert_eq!(model.gradle[0].dir, "b");
+    host.shutdown().await;
+}
diff --git a/crates/ide-host/tests/open_project.rs b/crates/ide-host/tests/open_project.rs
new file mode 100644
index 000000000..37ec7c417
--- /dev/null
+++ b/crates/ide-host/tests/open_project.rs
@@ -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");
+}
diff --git a/crates/ide-host/tests/plugins.rs b/crates/ide-host/tests/plugins.rs
index 299ece223..ee5db393a 100644
--- a/crates/ide-host/tests/plugins.rs
+++ b/crates/ide-host/tests/plugins.rs
@@ -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", "git@github.com: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("origin=git@github.com: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());
diff --git a/crates/ide-host/tests/project_smoke.rs b/crates/ide-host/tests/project_smoke.rs
index f8e7aed0a..9ed4cd4f4 100644
--- a/crates/ide-host/tests/project_smoke.rs
+++ b/crates/ide-host/tests/project_smoke.rs
@@ -223,7 +223,8 @@ async fn kotlin_gradle() {
     .await;
     let p = open("kotlin-gradle").await;
     let model = ops::build::build_model(&p.host, WINDOW).await.unwrap();
-    let gradle = model.gradle.expect("a Gradle model");
+    assert_eq!(model.gradle.len(), 1, "one independent Gradle build");
+    let gradle = &model.gradle[0];
     assert_eq!(gradle.projects.iter().map(|g| g.name.as_str()).collect::<Vec<_>>(), ["openidea-fixture-library"]);
 }
 
@@ -231,8 +232,9 @@ async fn kotlin_gradle() {
 async fn sync(fixture: &str, tool: ide_build::BuildTool) -> ide_build::BuildModel {
     let p = open(fixture).await;
     let progress = ops::Channel::new(|_: ide_build::SyncProgress| {});
-    let model =
-        ops::build::build_sync(&p.host, WINDOW, tool, ide_core::RequestId(1), false, vec![], progress).await.unwrap();
+    let model = ops::build::build_sync(&p.host, WINDOW, tool, ide_core::RequestId(1), false, vec![], None, progress)
+        .await
+        .unwrap();
     // The cached sync is what the next open shows.
     let reloaded = ops::build::build_model(&p.host, WINDOW).await.unwrap();
     assert_eq!(reloaded, model);
@@ -253,7 +255,9 @@ async fn maven_sync() {
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
 #[ignore = "project smoke: needs Gradle and a JDK"]
 async fn gradle_sync() {
-    let gradle = sync("kotlin-gradle", ide_build::BuildTool::Gradle).await.gradle.unwrap();
+    let model = sync("kotlin-gradle", ide_build::BuildTool::Gradle).await;
+    assert_eq!(model.gradle.len(), 1, "one independent Gradle build");
+    let gradle = &model.gradle[0];
     assert_eq!(gradle.sync_error, None);
     assert!(gradle.synced_at.is_some());
     let tasks: Vec<&str> = gradle.projects[0].tasks.iter().map(|t| t.name.as_str()).collect();
diff --git a/crates/ide-host/tests/trust.rs b/crates/ide-host/tests/trust.rs
index a5ec8d056..b50d5abce 100644
--- a/crates/ide-host/tests/trust.rs
+++ b/crates/ide-host/tests/trust.rs
@@ -249,6 +249,7 @@ async fn malicious_project_stays_editable_then_starts_in_place_after_trust() {
             ide_core::RequestId(472),
             false,
             vec![],
+            None,
             ops::Channel::new(|_| {}),
         )
     };
diff --git a/crates/ide-jsonrpc/src/lib.rs b/crates/ide-jsonrpc/src/lib.rs
index f78646ce2..6aa79979b 100644
--- a/crates/ide-jsonrpc/src/lib.rs
+++ b/crates/ide-jsonrpc/src/lib.rs
@@ -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"));
diff --git a/crates/ide-jsonrpc/src/tests.rs b/crates/ide-jsonrpc/src/tests.rs
index 9efee601c..c851cf66d 100644
--- a/crates/ide-jsonrpc/src/tests.rs
+++ b/crates/ide-jsonrpc/src/tests.rs
@@ -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.
diff --git a/crates/ide-notebook/src/document.rs b/crates/ide-notebook/src/document.rs
index 9eb328422..85d7661f6 100644
--- a/crates/ide-notebook/src/document.rs
+++ b/crates/ide-notebook/src/document.rs
@@ -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(),
diff --git a/crates/ide-plugin/Cargo.toml b/crates/ide-plugin/Cargo.toml
index 0c3bf091b..da304e85e 100644
--- a/crates/ide-plugin/Cargo.toml
+++ b/crates/ide-plugin/Cargo.toml
@@ -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"
diff --git a/crates/ide-plugin/src/runtime.rs b/crates/ide-plugin/src/runtime.rs
index 55c38e33f..e7fe25558 100644
--- a/crates/ide-plugin/src/runtime.rs
+++ b/crates/ide-plugin/src/runtime.rs
@@ -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/log@1.0.0`).
 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() }
     }
diff --git a/crates/ide-plugin/src/wit_host.rs b/crates/ide-plugin/src/wit_host.rs
index bcd53cc81..a1f7b7533 100644
--- a/crates/ide-plugin/src/wit_host.rs
+++ b/crates/ide-plugin/src/wit_host.rs
@@ -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 {
diff --git a/crates/ide-plugin/tests/check_component.rs b/crates/ide-plugin/tests/check_component.rs
new file mode 100644
index 000000000..6294a2266
--- /dev/null
+++ b/crates/ide-plugin/tests/check_component.rs
@@ -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/clipboard@1.0.0",
+        ),
+        ("no plugin exports", r#"(component (import "openidea:plugin/ui@1.0.0" (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}");
+    }
+}
diff --git a/crates/ide-plugin/tests/fixtures/hello/dist/plugin.wasm b/crates/ide-plugin/tests/fixtures/hello/dist/plugin.wasm
index 368de83b3..22be24d04 100644
Binary files a/crates/ide-plugin/tests/fixtures/hello/dist/plugin.wasm and b/crates/ide-plugin/tests/fixtures/hello/dist/plugin.wasm differ
diff --git a/crates/ide-plugin/tests/fixtures/hello/dist/plugin.wasm.sources b/crates/ide-plugin/tests/fixtures/hello/dist/plugin.wasm.sources
index f811c07c0..a78a811bf 100644
--- a/crates/ide-plugin/tests/fixtures/hello/dist/plugin.wasm.sources
+++ b/crates/ide-plugin/tests/fixtures/hello/dist/plugin.wasm.sources
@@ -1 +1 @@
-1f7402e2b1b4602e4073eb61837c3dc8840f9a4f7275d800dbd6fcf6ce5e40c3
+455d848dd27f242bb3e9bf420558cbc8c200853f51ada3d481635ac9771803f3
diff --git a/crates/ide-plugin/tests/fixtures/jobs/dist/plugin.wasm b/crates/ide-plugin/tests/fixtures/jobs/dist/plugin.wasm
index 0899f53e8..6cc5e751a 100644
Binary files a/crates/ide-plugin/tests/fixtures/jobs/dist/plugin.wasm and b/crates/ide-plugin/tests/fixtures/jobs/dist/plugin.wasm differ
diff --git a/crates/ide-plugin/tests/fixtures/jobs/dist/plugin.wasm.sources b/crates/ide-plugin/tests/fixtures/jobs/dist/plugin.wasm.sources
index 3a0de87f3..30532e592 100644
--- a/crates/ide-plugin/tests/fixtures/jobs/dist/plugin.wasm.sources
+++ b/crates/ide-plugin/tests/fixtures/jobs/dist/plugin.wasm.sources
@@ -1 +1 @@
-4f6cd5b5e0c12e7dcbccf66a6ad97276bf968bc3ad26f0fd08e1f7765cbfee14
+f7e1ae06a90460ed1d2319bfc51f848654df145fa451f3d959b32776b2b25ce3
diff --git a/crates/ide-plugin/tests/fixtures/jobs/plugin.toml b/crates/ide-plugin/tests/fixtures/jobs/plugin.toml
index 8fc682061..7453c9ec5 100644
--- a/crates/ide-plugin/tests/fixtures/jobs/plugin.toml
+++ b/crates/ide-plugin/tests/fixtures/jobs/plugin.toml
@@ -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"
diff --git a/crates/ide-plugin/tests/fixtures/jobs/src/lib.rs b/crates/ide-plugin/tests/fixtures/jobs/src/lib.rs
index fe28d779a..131ef2cce 100644
--- a/crates/ide-plugin/tests/fixtures/jobs/src/lib.rs
+++ b/crates/ide-plugin/tests/fixtures/jobs/src/lib.rs
@@ -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}"))),
         }
     }
diff --git a/crates/ide-plugin/tests/fixtures/misbehave/dist/plugin.wasm b/crates/ide-plugin/tests/fixtures/misbehave/dist/plugin.wasm
index 37db117ec..70f536a98 100644
Binary files a/crates/ide-plugin/tests/fixtures/misbehave/dist/plugin.wasm and b/crates/ide-plugin/tests/fixtures/misbehave/dist/plugin.wasm differ
diff --git a/crates/ide-plugin/tests/fixtures/misbehave/dist/plugin.wasm.sources b/crates/ide-plugin/tests/fixtures/misbehave/dist/plugin.wasm.sources
index f95fc1ae3..d08b0b0e8 100644
--- a/crates/ide-plugin/tests/fixtures/misbehave/dist/plugin.wasm.sources
+++ b/crates/ide-plugin/tests/fixtures/misbehave/dist/plugin.wasm.sources
@@ -1 +1 @@
-3d4dd1b6365c7fbafdd3c1f99f4405e5ee40fc5e56c97da960adfe7af2e7edb8
+12973c7ca7330fc50eb16718fd769d412401b5a92bd014f4804659e4a272122f
diff --git a/crates/ide-plugin/tests/fixtures/misbehave/src/lib.rs b/crates/ide-plugin/tests/fixtures/misbehave/src/lib.rs
index 890bf845b..35be7a7a0 100644
--- a/crates/ide-plugin/tests/fixtures/misbehave/src/lib.rs
+++ b/crates/ide-plugin/tests/fixtures/misbehave/src/lib.rs
@@ -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",
diff --git a/crates/ide-run/src/detect.rs b/crates/ide-run/src/detect.rs
index acb7e87dc..b7bc88027 100644
--- a/crates/ide-run/src/detect.rs
+++ b/crates/ide-run/src/detect.rs
@@ -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);
         }
diff --git a/crates/ide-run/src/import/jetbrains.rs b/crates/ide-run/src/import/jetbrains.rs
index 6d9dac06b..57ebe2c12 100644
--- a/crates/ide-run/src/import/jetbrains.rs
+++ b/crates/ide-run/src/import/jetbrains.rs
@@ -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 {
diff --git a/crates/ide-run/src/tomcat.rs b/crates/ide-run/src/tomcat.rs
index 4eb198b37..ab49e617d 100644
--- a/crates/ide-run/src/tomcat.rs
+++ b/crates/ide-run/src/tomcat.rs
@@ -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();
diff --git a/crates/ide-run/tests/detect.rs b/crates/ide-run/tests/detect.rs
index 80e54c385..aebe520c2 100644
--- a/crates/ide-run/tests/detect.rs
+++ b/crates/ide-run/tests/detect.rs
@@ -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"]);
diff --git a/crates/ide-run/tests/import_jetbrains.rs b/crates/ide-run/tests/import_jetbrains.rs
index f2f1da94d..d50d714df 100644
--- a/crates/ide-run/tests/import_jetbrains.rs
+++ b/crates/ide-run/tests/import_jetbrains.rs
@@ -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);
+}
diff --git a/crates/ide-sdk/src/apply.rs b/crates/ide-sdk/src/apply.rs
index bfa331397..11888554c 100644
--- a/crates/ide-sdk/src/apply.rs
+++ b/crates/ide-sdk/src/apply.rs
@@ -429,6 +429,36 @@ pub fn configure_maven_import(
     }
 }
 
+/// Explicit Gradle links constrain discovery and isolate JDT's persisted import state.
+pub fn configure_gradle_import(
+    cfg: &mut LanguageServerConfig,
+    linked: Option<&[String]>,
+    build_files: Option<&[String]>,
+) {
+    let Some(linked) = linked.filter(|_| cfg.name == "jdtls") else { return };
+    merge_init_options(
+        cfg,
+        json!({
+            "settings": {"java": {"import": {"gradle": {"enabled": !linked.is_empty()}}}},
+            "projectConfigurations": build_files.unwrap_or_default()
+        }),
+    );
+    if let Some(settings) = &mut cfg.settings {
+        merge(settings, json!({"java": {"import": {"gradle": {"enabled": !linked.is_empty()}}}}));
+    }
+    if let Some(index) = cfg.args.iter().position(|arg| arg == "-data")
+        && let Some(workspace) = cfg.args.get_mut(index + 1)
+    {
+        let mut hash = 0xcbf29ce484222325u64;
+        for dir in linked {
+            for byte in dir.bytes().chain([0]) {
+                hash = (hash ^ u64::from(byte)).wrapping_mul(0x100000001b3);
+            }
+        }
+        *workspace = format!("{workspace}-gradle-{hash:016x}");
+    }
+}
+
 pub(crate) fn merge_init_options(cfg: &mut LanguageServerConfig, layer: Value) {
     let mut current =
         cfg.initialization_options.as_ref().and_then(|v| serde_json::to_value(v).ok()).unwrap_or_else(|| json!({}));
@@ -1218,6 +1248,25 @@ mod java_compiler_tests {
 mod maven_linkage_tests {
     use super::*;
 
+    #[test]
+    fn explicit_gradle_links_scope_jdt_import_and_unlink_all_disables_gradle() {
+        let mut cfg = custom_server("jdtls", &LanguageServerSettings::default());
+        cfg.args = vec!["-data".into(), "/cache/jdtls".into()];
+        let files = ["file:///p/a/settings.gradle".to_owned(), "file:///p/maven/pom.xml".to_owned()];
+        configure_gradle_import(&mut cfg, Some(&["a".into()]), Some(&files));
+        let options = serde_json::to_value(&cfg.initialization_options).unwrap();
+        assert_eq!(options["projectConfigurations"], json!(files));
+        assert_eq!(options.pointer("/settings/java/import/gradle/enabled"), Some(&json!(true)));
+        assert!(cfg.args[1].starts_with("/cache/jdtls-gradle-"));
+        let linked_cache = cfg.args[1].clone();
+        cfg.args[1] = "/cache/jdtls".into();
+        configure_gradle_import(&mut cfg, Some(&[]), Some(&files[1..]));
+        let options = serde_json::to_value(&cfg.initialization_options).unwrap();
+        assert_eq!(options["projectConfigurations"], json!(&files[1..]));
+        assert_eq!(options.pointer("/settings/java/import/gradle/enabled"), Some(&json!(false)));
+        assert_ne!(linked_cache, cfg.args[1]);
+    }
+
     #[test]
     fn import_excludes_unlinked_modules_and_changes_persistent_workspace() {
         let tmp = tempfile::tempdir().unwrap();
diff --git a/crates/ide-sdk/src/discover.rs b/crates/ide-sdk/src/discover.rs
index e18b2dae8..d5141e270 100644
--- a/crates/ide-sdk/src/discover.rs
+++ b/crates/ide-sdk/src/discover.rs
@@ -184,6 +184,12 @@ fn python(root: Option<&Path>) -> Vec<Sdk> {
     par_map(&candidates, |(path, source)| python_sdk(path, source, root))
 }
 
+/// Interpreter `path` (one the project is set to, wherever it lives) as an SDK, named
+/// like the detected ones.
+pub fn python_interpreter_sdk(path: &Path, root: Option<&Path>) -> Option<Sdk> {
+    python_sdk(path, if venv_of(path).is_some() { "venv" } else { "system" }, root)
+}
+
 pub(crate) fn python_sdk(path: &Path, source: &str, root: Option<&Path>) -> Option<Sdk> {
     let version = query(path, &["--version"], VERSION_TIMEOUT)
         .and_then(|v| v.strip_prefix("Python ").map(str::to_owned))
@@ -193,10 +199,11 @@ pub(crate) fn python_sdk(path: &Path, source: &str, root: Option<&Path>) -> Opti
     let label = match (&venv, source) {
         (Some(home), _) => {
             let dir = home.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
-            // `.venv` inside a project reads better as the project name, like PyCharm.
+            // `.venv` inside a project reads better as the folder that holds it (the project,
+            // or a member such as `backend`), like PyCharm.
             let owner = home.parent().and_then(|p| p.file_name()).map(|n| n.to_string_lossy().into_owned());
             match (dir.starts_with('.') || dir == "venv" || dir == "env", owner, root) {
-                (true, Some(owner), Some(root)) if home.parent() == Some(root) => format!("Python {short} ({owner})"),
+                (true, Some(owner), Some(root)) if home.starts_with(root) => format!("Python {short} ({owner})"),
                 _ => format!("Python {short} ({dir})"),
             }
         }
diff --git a/crates/ide-sdk/src/lib.rs b/crates/ide-sdk/src/lib.rs
index 35d524173..90c5cae24 100644
--- a/crates/ide-sdk/src/lib.rs
+++ b/crates/ide-sdk/src/lib.rs
@@ -28,7 +28,7 @@ use serde::{Deserialize, Serialize};
 use specta::Type;
 use std::path::{Path, PathBuf};
 
-pub use discover::{detect, jdk_sdk};
+pub use discover::{detect, jdk_sdk, python_interpreter_sdk};
 
 /// What [`detect`] looks for.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
diff --git a/crates/ide-sdk/src/tests.rs b/crates/ide-sdk/src/tests.rs
index 7a8bd1033..84a45bb8d 100644
--- a/crates/ide-sdk/src/tests.rs
+++ b/crates/ide-sdk/src/tests.rs
@@ -76,6 +76,23 @@ fn project_venv_is_the_default_interpreter() {
     assert_eq!(python_interpreter(tmp.path(), &s).unwrap(), Path::new("/opt/py/bin/python3"));
 }
 
+#[test]
+fn an_interpreter_outside_detection_is_named_like_a_detected_one() {
+    let tmp = tempfile::tempdir().unwrap();
+    let root = tmp.path().join("shop");
+    let member = fake_venv(&root.join("backend"), ".venv");
+    let sdk = crate::python_interpreter_sdk(&member, Some(&root)).unwrap();
+    assert_eq!(
+        (sdk.name.as_str(), sdk.version.as_deref(), sdk.source.as_str()),
+        ("Python 3.12 (backend)", Some("3.12.1"), "venv")
+    );
+    let own = fake_venv(&root, ".venv");
+    assert_eq!(crate::python_interpreter_sdk(&own, Some(&root)).unwrap().name, "Python 3.12 (shop)");
+    // Outside the project the folder name says which one it is.
+    let elsewhere = fake_venv(&tmp.path().join("other"), ".venv");
+    assert_eq!(crate::python_interpreter_sdk(&elsewhere, Some(&root)).unwrap().name, "Python 3.12 (.venv)");
+}
+
 #[test]
 fn pyright_gets_python_path_and_venv_env() {
     let tmp = tempfile::tempdir().unwrap();
diff --git a/crates/ide-terminal/src/lib.rs b/crates/ide-terminal/src/lib.rs
index f08b3a069..ebe53e311 100644
--- a/crates/ide-terminal/src/lib.rs
+++ b/crates/ide-terminal/src/lib.rs
@@ -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"), &[]);
diff --git a/crates/ide-vcs/src/history.rs b/crates/ide-vcs/src/history.rs
index be0da59bf..14873f7b3 100644
--- a/crates/ide-vcs/src/history.rs
+++ b/crates/ide-vcs/src/history.rs
@@ -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)
diff --git a/crates/ide-vcs/src/lib.rs b/crates/ide-vcs/src/lib.rs
index 7adf881eb..e21f689cc 100644
--- a/crates/ide-vcs/src/lib.rs
+++ b/crates/ide-vcs/src/lib.rs
@@ -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())
     }
diff --git a/crates/ide-vcs/src/log_index.rs b/crates/ide-vcs/src/log_index.rs
index c1d013aad..e837f3603 100644
--- a/crates/ide-vcs/src/log_index.rs
+++ b/crates/ide-vcs/src/log_index.rs
@@ -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)
     }
 }
 
diff --git a/crates/ide-vcs/src/repo.rs b/crates/ide-vcs/src/repo.rs
index 6ad81787e..4f6cc2eff 100644
--- a/crates/ide-vcs/src/repo.rs
+++ b/crates/ide-vcs/src/repo.rs
@@ -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(),
     }))
 }
diff --git a/crates/ide-vcs/tests/log_projection.rs b/crates/ide-vcs/tests/log_projection.rs
index 10c9c61a8..a10d7dd63 100644
--- a/crates/ide-vcs/tests/log_projection.rs
+++ b/crates/ide-vcs/tests/log_projection.rs
@@ -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());
+}
diff --git a/crates/ide-vfs/src/lib.rs b/crates/ide-vfs/src/lib.rs
index 3941e8ba9..ab9d2dfdb 100644
--- a/crates/ide-vfs/src/lib.rs
+++ b/crates/ide-vfs/src/lib.rs
@@ -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);
 
diff --git a/crates/ide-vfs/src/rules.rs b/crates/ide-vfs/src/rules.rs
index 59a45cbd8..cad487a4c 100644
--- a/crates/ide-vfs/src/rules.rs
+++ b/crates/ide-vfs/src/rules.rs
@@ -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()));
+    }
 }
diff --git a/crates/ide-workspace/src/lib.rs b/crates/ide-workspace/src/lib.rs
index 18c29fc18..cc8fce280 100644
--- a/crates/ide-workspace/src/lib.rs
+++ b/crates/ide-workspace/src/lib.rs
@@ -25,7 +25,7 @@ pub use editorconfig::{EditorConfig, EditorConfigProps};
 pub use file_defaults::FileDefaults;
 pub use file_moves::{FileMove, FileMoves, UndoOutcome};
 pub use history::{DirectoryHistory, HistoryEntry, HistoryKind, LocalHistory, Retention};
-pub use recent::{RecentProject, RecentProjects};
+pub use recent::{RecentProject, RecentProjectGroup, RecentProjects};
 pub use roots::{ProjectRoots, RootKind, SourceFolder};
 pub use settings::{SettingsScope, SettingsStore};
 
diff --git a/crates/ide-workspace/src/recent.rs b/crates/ide-workspace/src/recent.rs
index 3c05e178b..ebb49a69f 100644
--- a/crates/ide-workspace/src/recent.rs
+++ b/crates/ide-workspace/src/recent.rs
@@ -16,10 +16,78 @@ pub struct RecentProject {
 
 pub const MAX_RECENT_PROJECTS: usize = 30;
 
-/// Persisted at `<app-config>/recent.json`, newest first.
+/// A named group of recent projects on the welcome screen (New Project Group…, Move to Group).
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct RecentProjectGroup {
+    pub name: String,
+    /// Its projects, in the order they were added.
+    pub paths: Vec<ide_core::IpcPath>,
+    #[serde(default = "expanded")]
+    pub expanded: bool,
+}
+
+fn expanded() -> bool {
+    true
+}
+
+/// Persisted at `<app-config>/recent.json`, newest first; groups at `<app-config>/recent-groups.json`.
 pub struct RecentProjects {
     file: PathBuf,
     items: Mutex<Vec<RecentProject>>,
+    groups_file: PathBuf,
+    groups: Mutex<Vec<RecentProjectGroup>>,
+}
+
+fn read_json<T: serde::de::DeserializeOwned>(file: &Path) -> Option<T> {
+    match std::fs::read(file) {
+        Ok(bytes) => serde_json::from_slice(&bytes)
+            .map_err(|e| tracing::warn!("{} is invalid, ignoring: {e}", file.display()))
+            .ok(),
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => None,
+        Err(e) => {
+            tracing::warn!("cannot read {}: {e}", file.display());
+            None
+        }
+    }
+}
+
+fn write_json<T: Serialize + ?Sized>(file: &Path, value: &T) -> IdeResult<()> {
+    if let Some(dir) = file.parent() {
+        std::fs::create_dir_all(dir)?;
+    }
+    let json = serde_json::to_vec_pretty(value).map_err(|e| IdeError::internal(e.to_string()))?;
+    ide_vfs::write_atomic(file, &json)?;
+    Ok(())
+}
+
+/// Each path in one group at most (the first keeps it), group names trimmed and unique.
+fn normalize(groups: Vec<RecentProjectGroup>) -> Vec<RecentProjectGroup> {
+    let mut paths = std::collections::HashSet::new();
+    let mut names = std::collections::HashSet::new();
+    groups
+        .into_iter()
+        .filter_map(|mut g| {
+            g.name = g.name.trim().to_owned();
+            if g.name.is_empty() || !names.insert(g.name.clone()) {
+                return None;
+            }
+            g.paths.retain(|p| paths.insert(p.clone()));
+            Some(g)
+        })
+        .collect()
+}
+
+/// Keeps the newest [`MAX_RECENT_PROJECTS`] projects outside groups; grouped ones stay.
+fn cap(items: &mut Vec<RecentProject>, groups: &[RecentProjectGroup]) {
+    let mut ungrouped = 0;
+    items.retain(|p| {
+        if groups.iter().any(|g| g.paths.contains(&p.path)) {
+            return true;
+        }
+        ungrouped += 1;
+        ungrouped <= MAX_RECENT_PROJECTS
+    });
 }
 
 fn now_ms() -> f64 {
@@ -29,28 +97,40 @@ fn now_ms() -> f64 {
 impl RecentProjects {
     pub fn load(config_dir: &Path) -> Self {
         let file = config_dir.join("recent.json");
-        let mut items: Vec<RecentProject> = match std::fs::read(&file) {
-            Ok(bytes) => serde_json::from_slice(&bytes).unwrap_or_else(|e| {
-                tracing::warn!("{} is invalid, ignoring: {e}", file.display());
-                Vec::new()
-            }),
-            Err(e) if e.kind() == std::io::ErrorKind::NotFound => Vec::new(),
-            Err(e) => {
-                tracing::warn!("cannot read {}: {e}", file.display());
-                Vec::new()
-            }
-        };
+        let groups_file = config_dir.join("recent-groups.json");
+        let mut items: Vec<RecentProject> = read_json(&file).unwrap_or_default();
+        let mut groups = normalize(read_json(&groups_file).unwrap_or_default());
         items.sort_by(|a, b| b.opened_at_ms.total_cmp(&a.opened_at_ms));
         let mut seen = std::collections::HashSet::new();
         items.retain(|p| seen.insert(p.path.clone()));
-        items.truncate(MAX_RECENT_PROJECTS);
-        Self { file, items: Mutex::new(items) }
+        cap(&mut items, &groups);
+        // A group lists only projects that are still recent.
+        for g in &mut groups {
+            g.paths.retain(|p| items.iter().any(|i| i.path == *p));
+        }
+        Self { file, items: Mutex::new(items), groups_file, groups: Mutex::new(groups) }
     }
 
     pub fn list(&self) -> Vec<RecentProject> {
         self.items.lock().clone()
     }
 
+    pub fn groups(&self) -> Vec<RecentProjectGroup> {
+        self.groups.lock().clone()
+    }
+
+    /// Replaces the groups (paths that are not recent projects are dropped).
+    pub fn set_groups(&self, groups: Vec<RecentProjectGroup>) -> IdeResult<Vec<RecentProjectGroup>> {
+        let items = self.items.lock();
+        let mut groups = normalize(groups);
+        for g in &mut groups {
+            g.paths.retain(|p| items.iter().any(|i| i.path == *p));
+        }
+        write_json(&self.groups_file, &groups)?;
+        *self.groups.lock() = groups.clone();
+        Ok(groups)
+    }
+
     /// Moves (or adds) `path` to the top of the list.
     pub fn touch(&self, path: &Path, branch: Option<String>) -> IdeResult<()> {
         let mut items = self.items.lock();
@@ -58,7 +138,7 @@ impl RecentProjects {
         let name =
             path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_else(|| path.display().to_string());
         items.insert(0, RecentProject { path: path.into(), name, opened_at_ms: now_ms(), branch });
-        items.truncate(MAX_RECENT_PROJECTS);
+        cap(&mut items, &self.groups.lock());
         self.persist(&items)
     }
 
@@ -83,7 +163,15 @@ impl RecentProjects {
         if items.len() == before {
             return Ok(());
         }
-        self.persist(&items)
+        self.persist(&items)?;
+        let mut groups = self.groups.lock();
+        if groups.iter().any(|g| g.paths.iter().any(|p| p == path)) {
+            for g in groups.iter_mut() {
+                g.paths.retain(|p| p != path);
+            }
+            write_json(&self.groups_file, &*groups)?;
+        }
+        Ok(())
     }
 
     pub fn paths(&self) -> Vec<PathBuf> {
@@ -91,12 +179,7 @@ impl RecentProjects {
     }
 
     fn persist(&self, items: &[RecentProject]) -> IdeResult<()> {
-        if let Some(dir) = self.file.parent() {
-            std::fs::create_dir_all(dir)?;
-        }
-        let json = serde_json::to_vec_pretty(items).map_err(|e| IdeError::internal(e.to_string()))?;
-        ide_vfs::write_atomic(&self.file, &json)?;
-        Ok(())
+        write_json(&self.file, items)
     }
 }
 
@@ -131,6 +214,41 @@ mod tests {
         assert!(RecentProjects::load(&cfg).list().is_empty());
     }
 
+    #[test]
+    fn groups_keep_their_projects_and_survive_a_reload() {
+        let tmp = tempfile::tempdir().unwrap();
+        let recent = RecentProjects::load(tmp.path());
+        for i in 0..3 {
+            recent.touch(&PathBuf::from(format!("/p/proj{i}")), None).unwrap();
+        }
+        let group = |name: &str, paths: &[&str]| RecentProjectGroup {
+            name: name.into(),
+            paths: paths.iter().map(|p| PathBuf::from(p).into()).collect(),
+            expanded: true,
+        };
+        let saved = recent
+            .set_groups(vec![
+                group(" Work ", &["/p/proj0", "/p/gone"]),
+                group("Work", &["/p/proj1"]),
+                group("Oss", &["/p/proj0", "/p/proj2"]),
+                group("  ", &[]),
+            ])
+            .unwrap();
+        // Trimmed, unique names; each project in one group; only recent projects.
+        assert_eq!(saved, vec![group("Work", &["/p/proj0"]), group("Oss", &["/p/proj2"])]);
+        assert_eq!(RecentProjects::load(tmp.path()).groups(), saved);
+
+        // A grouped project outlives the cap; removing it from recent projects ungroups it.
+        for i in 3..40 {
+            recent.touch(&PathBuf::from(format!("/p/proj{i}")), None).unwrap();
+        }
+        let paths = recent.paths();
+        assert_eq!(paths.len(), MAX_RECENT_PROJECTS + 2);
+        assert!(paths.contains(&PathBuf::from("/p/proj0")) && paths.contains(&PathBuf::from("/p/proj2")));
+        recent.remove(Path::new("/p/proj2")).unwrap();
+        assert_eq!(RecentProjects::load(tmp.path()).groups(), vec![group("Work", &["/p/proj0"]), group("Oss", &[])]);
+    }
+
     #[test]
     fn rename_shows_a_custom_name_until_reset() {
         let tmp = tempfile::tempdir().unwrap();
diff --git a/docs/assets/wechat-group.png b/docs/assets/wechat-group.png
new file mode 100644
index 000000000..1f4f7903b
Binary files /dev/null and b/docs/assets/wechat-group.png differ
diff --git a/docs/plugins/themes.md b/docs/plugins/themes.md
index e28db7a85..06f620a9d 100644
--- a/docs/plugins/themes.md
+++ b/docs/plugins/themes.md
@@ -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.
 
diff --git a/docs/workspaces-and-window-groups.md b/docs/workspaces-and-window-groups.md
index 48937ffb3..02136699c 100644
--- a/docs/workspaces-and-window-groups.md
+++ b/docs/workspaces-and-window-groups.md
@@ -22,7 +22,15 @@ Paths in an existing manifest may be relative to the workspace directory. New an
 
 Linked folders appear as roots in Project view and participate in indexing, Find in Files, Git repository discovery and language-server root selection. Detected and saved run configurations have project-qualified names and use their member's working directory and launch settings. Build Project combines the linked projects' build plans; Compile File targets its owning project. Workspace editor/settings state belongs to its own directory. Each member retains its repository and project configuration.
 
-The specialized Maven/Gradle tool-window model still describes the workspace directory itself; it does not yet aggregate independent member models. Workspace creation and management currently target local folders.
+The specialized Maven/Gradle tool-window model still describes the workspace directory itself; it does not yet aggregate independent member models. Workspace creation and management currently target local folders. To link independent Gradle builds in one Gradle tree, open their parent folder as an ordinary project instead of creating a Workspace manifest, then use **Link Gradle Projects…** in the Gradle toolbar or Find Action.
+
+## Linked Gradle builds in a project
+
+In an ordinary project window, **Link Gradle Projects…** accepts one or more `settings.gradle`, `settings.gradle.kts`, `build.gradle`, or `build.gradle.kts` files. Each linked build has its own root in the Gradle tool window. Its tasks, dependencies, wrapper, working directory and sync cache stay separate, even when another build has the same `:app` project or task names. Included builds remain under the build that includes them.
+
+Right-click a build root for **Reload Gradle Project** or **Unlink Gradle Project**. Unlinking only removes the IDE connection; it does not delete files or saved run configurations. The Link button remains available after the last build is unlinked. Linked builds may live outside the opened folder.
+
+Links are saved in project settings as `languages.java.gradle.linkedProjects`. Until links are configured, existing automatic discovery is unchanged. An explicit empty list means that no Gradle builds are linked. Opening the project again restores its links. A folder first opened by an older version may need one fresh sync because independent builds now have separate caches.
 
 ## Window group
 
diff --git a/e2e/icls-php.spec.ts b/e2e/icls-php.spec.ts
new file mode 100644
index 000000000..6a199e61e
--- /dev/null
+++ b/e2e/icls-php.spec.ts
@@ -0,0 +1,77 @@
+import { readFileSync } from "node:fs";
+import { expect, test } from "./fixtures";
+
+const xml = readFileSync(
+  process.env.OPENIDEA_ICLS_FIXTURE ?? "src/platform/__fixtures__/colorSchemes/monokai-php.icls",
+  "utf8",
+);
+
+test("imported PHP colours stay separate from Java and preserve regular text on a dark background", async ({
+  workbench: page,
+}, info) => {
+  await page.evaluate(async (xml) => {
+    const iclsPath = "/src/platform/icls.ts";
+    const projectPath = "/src/platform/project.ts";
+    const backendPath = "/src/editor/core/backend.ts";
+    const contributionsPath = "/src/workbench/contributions.ts";
+    const { parseIcls } = await import(iclsPath);
+    const { useProject } = await import(projectPath);
+    const { docBackend } = await import(backendPath);
+    const { editorService } = await import(contributionsPath);
+    const previous = useProject.getState().settings ?? {};
+    useProject.setState({
+      settings: {
+        ...previous,
+        editor: {
+          ...previous.editor,
+          colorScheme: "custom-php",
+          customSchemes: { "custom-php": parseIcls(xml).scheme },
+          semanticHighlighting: false,
+        },
+      },
+    });
+    const backend = docBackend();
+    const open = backend.open.bind(backend);
+    backend.open = async (...args: Parameters<typeof open>) => {
+      const result = await open(...args);
+      return args[0].endsWith(".php") ? { ...result, language: "php", uiMode: "PHP" } : result;
+    };
+    backend.files.set(
+      "/dev/acme-api/palette.php",
+      "<?php\n/** Plain PHP documentation */\nclass Palette extends BasePalette {\n    var $name = 'Palette';\n    function example($value) {\n        return $this->name == 10;\n    }\n}\n",
+    );
+    await editorService().openFile("/dev/acme-api/palette.php");
+  }, xml);
+  const php = page.locator('.cm-editor[data-language="PHP"]');
+  await expect(php).toBeVisible();
+  await expect(php).toHaveCSS("background-color", "rgb(0, 0, 0)");
+  const token = (text: string) =>
+    php
+      .locator(".cm-content span")
+      .filter({ hasText: text })
+      .filter({ hasNot: php.locator("span span") });
+  await expect(token("$name").first()).toHaveCSS("color", "rgb(72, 216, 238)");
+  await expect(token("'Palette'")).toHaveCSS("color", "rgb(255, 231, 146)");
+  await expect(token("'Palette'")).toHaveCSS("font-weight", "400");
+  await expect(token("class").first()).toHaveCSS("color", "rgb(249, 38, 114)");
+  await expect(token("Plain PHP documentation")).toHaveCSS("font-style", "normal");
+  await expect(token("BasePalette")).toHaveCSS("color", "rgb(174, 129, 255)");
+  await expect(token(";").first()).toHaveCSS("color", "rgb(255, 255, 255)");
+  await expect(token("example")).toHaveCSS("color", "rgb(141, 225, 45)");
+  await expect(token("$name").first()).toHaveCSS("font-weight", "700");
+  await page.evaluate(async () => {
+    const backendPath = "/src/editor/core/backend.ts";
+    const contributionsPath = "/src/workbench/contributions.ts";
+    const { docBackend } = await import(backendPath);
+    const { editorService } = await import(contributionsPath);
+    docBackend().files.set("/dev/acme-api/Palette.java", 'class Palette { String name = "Palette"; }');
+    await editorService().openFile("/dev/acme-api/Palette.java");
+  });
+  const java = page.locator('.cm-editor[data-language="Java"]');
+  await expect(java).toBeVisible();
+  await expect(java.locator(".cm-content span").filter({ hasText: '"Palette"' })).toHaveCSS("font-weight", "700");
+  await page.getByRole("tab", { name: "palette.php", exact: true }).click();
+  await expect(php).toBeVisible();
+  await expect(token("'Palette'")).toHaveCSS("font-weight", "400");
+  await php.screenshot({ path: info.outputPath("php-import.png"), animations: "disabled" });
+});
diff --git a/e2e/linkedGradle.spec.ts b/e2e/linkedGradle.spec.ts
new file mode 100644
index 000000000..0ee3dc8c0
--- /dev/null
+++ b/e2e/linkedGradle.spec.ts
@@ -0,0 +1,120 @@
+/** Linked Gradle builds use isolated native stubs; no real builds or files are touched. */
+import type { GradleModel, RunConfig } from "../src/platform/ipc";
+import { expect, ipcCalls, stubDesktop, test } from "./fixtures";
+
+const build = (dir: string): GradleModel => ({
+  dir,
+  command: `/dev/acme-api/${dir}/gradlew`,
+  env: { JAVA_HOME: `/${dir}/jdk` },
+  javaVersion: 21,
+  syncedAt: 1,
+  stale: false,
+  syncError: null,
+  projects: [
+    { path: ":", name: dir, dir, buildFile: `${dir}/build.gradle`, tasks: [] },
+    {
+      path: ":app",
+      name: "app",
+      dir: `${dir}/app`,
+      buildFile: `${dir}/app/build.gradle`,
+      tasks: [{ name: "assemble", group: "build", description: "Assembles this project" }],
+    },
+  ],
+});
+
+test("links independent Gradle roots, runs identical task paths in their own builds and unlinks without deletion", async ({
+  workbench: page,
+}, info) => {
+  await stubDesktop(page);
+  await page.evaluate(
+    async ({ first, second }) => {
+      let linked = [first];
+      let runId = 0;
+      const model = () => ({ maven: null, gradle: linked });
+      const h = window.__ipc.handlers;
+      h.build_model = model;
+      h.build_sync = model;
+      h.run_configs = () => [];
+      h.run_apply_settings = (args) => args.configs;
+      h.gradle_link_projects = () => {
+        if (!linked.some((g) => g.dir === second.dir)) linked = [...linked, second];
+        return model();
+      };
+      h.gradle_unlink_projects = (args) => {
+        linked = linked.filter((g) => !(args.paths as string[]).includes(g.dir));
+        return model();
+      };
+      h["plugin:dialog|open"] = () => ["/dev/acme-api/second/settings.gradle"];
+      h.run_start = (args) => {
+        const config = args.config as RunConfig;
+        const id = ++runId;
+        setTimeout(() => window.__ipc.emit({ type: "runExited", run: id, code: 0 }), 50);
+        return { id, configId: config.id, name: config.name, pid: 4242 + id, running: true, pty: false };
+      };
+      const storeModule = "/src/features/build-tools/store.ts";
+      const { loadModel } = await import(/* @vite-ignore */ storeModule);
+      await loadModel();
+      const contributionsModule = "/src/workbench/contributions.ts";
+      const { toolWindowService } = await import(/* @vite-ignore */ contributionsModule);
+      toolWindowService().show("gradle", true);
+    },
+    { first: build("first"), second: build("second") },
+  );
+
+  const tree = page.getByRole("tree", { name: "Gradle projects" });
+  await expect(tree.getByRole("treeitem", { name: "first", exact: true })).toBeVisible();
+  await expect(tree.getByRole("treeitem", { name: "second", exact: true })).toHaveCount(0);
+  await page.screenshot({ path: info.outputPath("gradle-one-root.png"), animations: "disabled" });
+
+  await page.getByRole("button", { name: "Link Gradle Projects", exact: true }).click();
+  await expect
+    .poll(() => ipcCalls(page, "gradle_link_projects"))
+    .toEqual([{ paths: ["/dev/acme-api/second/settings.gradle"] }]);
+  await expect(tree.getByRole("treeitem", { name: "second", exact: true })).toBeVisible();
+  // Reloading the model reads the persisted linkage again.
+  await page.evaluate(async () => {
+    const storeModule = "/src/features/build-tools/store.ts";
+    const { loadModel } = await import(/* @vite-ignore */ storeModule);
+    await loadModel();
+    const actionModule = "/src/platform/actions.ts";
+    const { executeAction } = await import(/* @vite-ignore */ actionModule);
+    await executeAction("gradle.expandAll");
+    await executeAction("gradle.toggleOffline");
+  });
+  const tasks = tree.getByRole("treeitem", { name: /^assemble\b/ });
+  await expect(tasks).toHaveCount(2);
+  await page.screenshot({ path: info.outputPath("gradle-two-roots.png"), animations: "disabled" });
+
+  await tasks.nth(0).dblclick();
+  await expect.poll(async () => (await ipcCalls(page, "run_start")).length).toBe(1);
+  await tasks.nth(1).dblclick();
+  await expect.poll(async () => (await ipcCalls(page, "run_start")).length).toBe(2);
+  const runs = (await ipcCalls(page, "run_start")).map((args) => args.config as RunConfig);
+  expect(runs[0]!.id).not.toBe(runs[1]!.id);
+  for (const [index, dir] of ["first", "second"].entries()) {
+    expect(runs[index]).toMatchObject({
+      command: `/dev/acme-api/${dir}/gradlew`,
+      cwd: dir,
+      args: [":app:assemble", "--offline"],
+      env: { JAVA_HOME: `/${dir}/jdk` },
+    });
+  }
+
+  for (const dir of ["second", "first"]) {
+    await tree.getByRole("treeitem", { name: dir, exact: true }).click({ button: "right" });
+    await page.getByRole("menuitem", { name: "Unlink Gradle Project", exact: true }).click();
+    const dialog = page.getByRole("dialog", { name: "Unlink Gradle project?" });
+    await expect(dialog).toContainText("Files will remain");
+    await dialog.getByRole("button", { name: "Unlink", exact: true }).click();
+    await expect(tree.getByRole("treeitem", { name: dir, exact: true })).toHaveCount(0);
+  }
+  await expect
+    .poll(() => ipcCalls(page, "gradle_unlink_projects"))
+    .toEqual([{ paths: ["second"] }, { paths: ["first"] }]);
+  await expect(page.getByText("No Gradle projects", { exact: true })).toBeVisible();
+  await expect(page.getByRole("button", { name: "Link Gradle Projects", exact: true })).toBeVisible();
+  expect(
+    await page.evaluate(() => window.__ipc.calls.filter((c) => /^fs_(?:delete|remove|trash)/.test(c.cmd))),
+  ).toEqual([]);
+  await page.screenshot({ path: info.outputPath("gradle-unlinked.png"), animations: "disabled" });
+});
diff --git a/e2e/overviewLaneSelection.spec.ts b/e2e/overviewLaneSelection.spec.ts
new file mode 100644
index 000000000..87eb037a6
--- /dev/null
+++ b/e2e/overviewLaneSelection.spec.ts
@@ -0,0 +1,28 @@
+import { expect, openFromTree, test } from "./fixtures";
+
+// Headless Chromium hides scrollbars by default, so nothing native sits at the editor's right
+// edge and the press reaches the overview lane. The tests in `overviewLane.spec.ts` keep a
+// scrollbar there instead.
+test("pressing the overview lane scrolls instead of starting a text selection", async ({ workbench: page }) => {
+  const editor = await openFromTree(page, "build.gradle.kts");
+  await editor.locator(".cm-content").click();
+  await page.keyboard.press("Meta+a");
+  await page.keyboard.insertText(Array.from({ length: 400 }, (_, i) => `val line${i} = ${i}`).join("\n"));
+  await page.keyboard.press("Escape");
+  const scroller = editor.locator(".cm-scroller");
+  await scroller.evaluate((s) => (s.scrollTop = 0));
+  const box = (await scroller.boundingBox())!;
+  // The lane replaces the native scrollbar: a press on it must stay a scrollbar press.
+  const x = box.x + box.width - 5;
+  const y = box.y + box.height - 40;
+  await page.mouse.move(x, y);
+  await page.mouse.down();
+  await page.mouse.move(x, y - 120, { steps: 8 });
+  await page.mouse.up();
+  const empty = await editor.locator(".cm-content").evaluate((el) => {
+    const view = (el as unknown as { cmTile: { view: { state: { selection: { main: { empty: boolean } } } } } }).cmTile
+      .view;
+    return view.state.selection.main.empty;
+  });
+  expect(empty).toBe(true);
+});
diff --git a/e2e/themes.spec.ts b/e2e/themes.spec.ts
index 74ee13e47..ce717dace 100644
--- a/e2e/themes.spec.ts
+++ b/e2e/themes.spec.ts
@@ -186,3 +186,49 @@ test("quick theme menu offers all four palettes and applies their kind", async (
     await expect(page.locator("html")).toHaveAttribute("data-theme", palette.kind);
   }
 });
+
+test("gear › Theme previews the theme under the pointer and keeps the one chosen", async ({ workbench: page }) => {
+  const html = page.locator("html");
+  const gear = page.getByRole("button", { name: "IDE and Project Settings", exact: true });
+  const theme = (label: string) => page.getByRole("menuitemcheckbox", { name: label, exact: true });
+  await gear.click();
+  await page.getByRole("menuitem", { name: "Theme", exact: true }).hover();
+  await theme("Solarized Dark").hover();
+  await expect(html).toHaveAttribute("data-color-theme", "solarized-dark");
+  // A plugin's theme previews too.
+  await theme("Harbor Night").hover();
+  await expect(html).toHaveAttribute("data-plugin-theme", /harbor-night$/);
+  await expect(html).not.toHaveAttribute("data-color-theme");
+  await page.keyboard.press("Escape");
+  await page.keyboard.press("Escape");
+  await expect(html).not.toHaveAttribute("data-plugin-theme");
+  await expect(html).toHaveAttribute("data-theme", "light");
+
+  await gear.click();
+  await page.getByRole("menuitem", { name: "Theme", exact: true }).hover();
+  await theme("One Dark").hover();
+  await expect(html).toHaveAttribute("data-color-theme", "one-dark");
+  await theme("One Dark").click();
+  await expect(html).toHaveAttribute("data-color-theme", "one-dark");
+  // Chosen, not previewed: the next start-up opens with it.
+  await expect
+    .poll(() => page.evaluate(() => JSON.parse(localStorage.getItem("openidea.theme") ?? "{}").colorTheme))
+    .toBe("one-dark");
+});
+
+test("Settings › Appearance › Theme previews the highlighted theme until Cancel", async ({ workbench: page }) => {
+  const html = page.locator("html");
+  const dialog = await settings(page);
+  await page.getByRole("button", { name: "Theme", exact: true }).click();
+  await page.getByRole("option", { name: "Solarized Dark", exact: true }).hover();
+  await expect(html).toHaveAttribute("data-color-theme", "solarized-dark");
+  await page.keyboard.press("Escape");
+  await expect(html).toHaveAttribute("data-theme", "light");
+  await expect(html).not.toHaveAttribute("data-color-theme");
+  // Picked: it shows until Apply or Cancel.
+  await choose(page, "Theme", "One Dark");
+  await expect(html).toHaveAttribute("data-color-theme", "one-dark");
+  await dialog.getByRole("button", { name: "Cancel", exact: true }).click();
+  await expect(html).toHaveAttribute("data-theme", "light");
+  await expect(html).not.toHaveAttribute("data-color-theme");
+});
diff --git a/languages/dart.toml b/languages/dart.toml
index d2cfdb3a5..402b6fbb4 100644
--- a/languages/dart.toml
+++ b/languages/dart.toml
@@ -14,8 +14,10 @@ args = ["language-server", "--protocol=lsp"]
 root-markers = ["pubspec.yaml", "analysis_options.yaml"]
 install-hint = "Install the Dart SDK (https://dart.dev/get-dart) or Flutter"
 
+# `dart` here; a project that depends on the Flutter SDK is switched to
+# `flutter debug_adapter` at session start (see `ide-dap`'s `start_with`).
 [debugger]
 adapter = "dart"
 command = "dart"
 args = ["debug_adapter"]
-install-hint = "Install the Dart SDK (https://dart.dev/get-dart); use `flutter debug_adapter` for Flutter apps"
+install-hint = "Install the Dart SDK (https://dart.dev/get-dart) or Flutter"
diff --git a/package.json b/package.json
index 5ba6e561e..538d9de5f 100644
--- a/package.json
+++ b/package.json
@@ -2,7 +2,7 @@
   "name": "openidea",
   "private": true,
   "description": "An open-source IDE inspired by IntelliJ IDEA",
-  "version": "0.1.36",
+  "version": "0.1.37",
   "license": "Apache-2.0",
   "type": "module",
   "scripts": {
diff --git a/plugins/README.md b/plugins/README.md
index 8a74a1d12..d2f1ab09d 100644
--- a/plugins/README.md
+++ b/plugins/README.md
@@ -11,9 +11,10 @@ editors, and contribute menus, shortcuts, settings, themes, file icon themes
 and languages. Plugins that only contribute data (themes, icons, languages,
 menus, settings) need no code at all.
 
-> **Preview.** The plugin system ships as a preview: until it is declared
-> stable the API (`openidea:plugin@1.0`) may still change, and the official
-> plugins are versioned `0.x`. See _Evolving the plugin API_ below.
+> **Preview.** The plugin system ships as a preview and the official plugins
+> are versioned `0.x`. Released API versions only grow: a plugin built for
+> `openidea:plugin@1.0` keeps loading in later 1.x IDEs. See _Evolving the
+> plugin API_ below.
 
 ```
 plugins/
@@ -36,7 +37,7 @@ sdk/rust/openidea-plugin/     # the Rust SDK (host API, Plugin trait, mock host)
 crates/ide-plugin/tests/fixtures/  # test plugins: hello, jobs, language-toy, misbehave
 ```
 
-The plugin API is defined in [`wit/`](../wit/) (`openidea:plugin@1.0.0`, world
+The plugin API is defined in [`wit/`](../wit/) (`openidea:plugin@1.1.0`, world
 `plugin`).
 
 ## 1. Quick start
@@ -71,7 +72,8 @@ target through rustup if needed), copies the component to the manifest's
 `wasm` path and runs `check`. `check` validates the package exactly as
 _Install Plugin from Disk…_ would — manifest, every contribution, the SVG
 sanitiser, the component — and that the component imports nothing but the
-plugin API and WASI. It prints what the user will be asked to grant.
+plugin API and WASI and links against the IDE's: every function it imports
+exists with the same signature, and it exports the plugin world. It prints what the user will be asked to grant.
 
 `link` adds the folder to `links.json` in the IDE's plugins directory
 (`$OPENIDEA_PLUGINS_DIR`, default `<app-data>/ai.l0ng.openidea/plugins`). Linked
@@ -183,7 +185,7 @@ machine. Users can revoke optional capabilities in Settings › Plugins.
 | `project.read`      | low    | `Project::root`, `read_file`, `find_files`, `host::projects`, `publish_diagnostics` |
 | `editor.read`       | low    | `TextEditor::document`, `selections`                                                |
 | `editor.write`      | medium | `TextEditor::apply_edits`                                                           |
-| `vcs.read`          | low    | `Project::vcs_status` (branch, upstream, ahead/behind, changes)                     |
+| `vcs.read`          | low    | `Project::vcs_status` (branch, upstream, ahead/behind, changes), `vcs_remotes`      |
 | `vcs.write`         | medium | `Project::vcs_fetch` (trusted projects only)                                        |
 | `storage`           | low    | `host::storage` (1 MiB per plugin)                                                  |
 | `events`            | low    | file opened/saved, editor focused, repository changed events                        |
@@ -191,7 +193,7 @@ machine. Users can revoke optional capabilities in Settings › Plugins.
 | `process:<program>` | high   | `Project::run_process`, language servers, debug adapters, runs                      |
 | `net:<host>`        | medium | `host::fetch` to that host (`*.example.com`: its subdomains)                        |
 | `secrets`           | medium | `{{secret:<name>}}` in request headers, `host::secret_is_set`                       |
-| `clipboard`         | medium | the clipboard API in the plugin's web views (keyboard copy / paste work without it) |
+| `clipboard`         | medium | `host::copy_to_clipboard` and the clipboard API in the plugin's web views           |
 
 `process:` capabilities are also derived from what the contributions start: a
 language's `language-servers` and `debugger` commands and a run detector's
@@ -299,12 +301,14 @@ then run `openidea-plugin check`.
 | `TextEditor::apply_edits(version, edits)`                                | `editor.text-editor.apply-edits` | One undoable change, only if the document is still at `version` — else `Error::Stale` and nothing changes. `transform_selections` retries once.                                                                      |
 | `Project::root()`, `read_file(path)`                                     | `workspace.project`              | Absolute or project-relative; `..`/symlinks escaping the root are rejected; UTF-8 only, ≤ 16 MiB; unsaved editor contents win.                                                                                       |
 | `host::projects()`                                                       | `workspace.projects`             | Every open project (for scheduled work without a window).                                                                                                                                                            |
-| `Project::vcs_status()`, `vcs_fetch()`                                   | `vcs`                            | Fetch runs git, so only in trusted projects; call it inside a task.                                                                                                                                                  |
+| `Project::vcs_status()`, `vcs_remotes()`, `vcs_fetch()`                  | `vcs`                            | `vcs_remotes` returns `(name, url)` pairs; fetch runs git, so only in trusted projects (call it inside a task).                                                                                                      |
 | `host::subscribe(kind)`                                                  | `events.subscribe`               | For the session, across idle reclaim (an event activates the plugin). Or declare `on-event:<kind>`.                                                                                                                  |
 | `host::begin_task(title, cancellable)` → `Task`                          | `tasks.begin`                    | Shown with the background tasks; `report`, `is_cancelled`; the call may run 60 s instead of 5 s while it is open; dropping it ends it.                                                                               |
 | `host::storage::{get, set, delete, keys}`                                | `storage`                        | Survives restarts; the instance's memory does not. Deleted on uninstall.                                                                                                                                             |
 | `host::set_status_item(id, item)`, `remove_status_item`                  | `ui`                             | `text`, `tooltip`, `command` (one of yours, run on click); at most 8; kept while the plugin is idle.                                                                                                                 |
 | `host::notify(level, title, body)`                                       | `ui.show-notification`           | Balloon in the window the command or events came from (every window otherwise).                                                                                                                                      |
+| `host::copy_to_clipboard(text)`                                          | `ui.copy-to-clipboard`           | Copies `text` to the system clipboard. Needs `clipboard`.                                                                                                                                                            |
+| `host::open_url(url)`                                                    | `ui.open-url`                    | Opens an `http://` or `https://` URL in the user's default browser.                                                                                                                                                  |
 | `host::log(level, msg)`                                                  | `log`                            | IDE log, tagged with the plugin id. `eprintln!` output is logged too and shown when the plugin crashes.                                                                                                              |
 | `Project::find_files(glob, limit)`                                       | `workspace.project.find-files`   | Project-relative glob (`**/*Mapper.xml`); honours `.gitignore`; at most `limit` paths.                                                                                                                               |
 | `host::publish_diagnostics(path, items)`                                 | `diagnostics.publish`            | Replaces this plugin's problems for the file (editor squiggles and the Problems view); an empty list clears them.                                                                                                    |
@@ -766,7 +770,7 @@ granted, and starts the approved program.
   the package at its root or in its only folder, or a folder's `plugin.toml`;
   a zip without a `plugin.toml` there, such as an IntelliJ plugin, is refused; IntelliJ
   theme plugins are imported instead: _Import IntelliJ Theme from File…_ and _Import Theme
-  from IntelliJ IDE…_, see [`docs/plugins/themes.md`](../docs/plugins/themes.md)). The install
+  from JetBrains IDE…_, see [`docs/plugins/themes.md`](../docs/plugins/themes.md)). The install
   page lists every capability and whether the package is signed by a publisher
   the marketplace trusts; nothing is copied until you accept.
 - **Versions:** installed plugins live in `<app-data>/plugins/<id>/<version>/`
@@ -916,8 +920,8 @@ the API itself follows _Evolving the plugin API_ below.
 
 ## 10. Evolving the plugin API
 
-While the plugin system is a preview the API may still change freely. Once it
-is declared stable wasmtime decides what stays compatible: it resolves interface names
+Released versions are frozen: 1.0.0 shipped with OpenIDEA 0.1.36 and 1.1.0
+with 0.1.37. wasmtime decides what stays compatible: it resolves interface names
 by semver (a component importing `openidea:plugin/x@1.0.0` links against a
 host defining `@1.1.0`, and the host finds its exports the same way), but
 function types must match exactly — a record with another field count, or a
@@ -942,6 +946,8 @@ only grows:
    its `openidea:plugin/*` imports and exports, `PluginEngine::check_component`).
    Installing and `openidea-plugin check` refuse another major or a newer
    minor with a message that says to update the IDE or rebuild with the SDK.
+   They also link the component, so one that imports a function this host
+   lacks under the same version (built from unreleased WIT) is refused too.
 5. **One version number**: the `wit/` package version, `ENGINE_VERSION` and
    `API_VERSION` agree, and the SDK's `wit/` copy is identical to `wit/`.
 6. **1.x calls are synchronous and pass documents whole.** Host calls block
@@ -952,10 +958,15 @@ only grows:
 
 Checked automatically:
 
-- SDK `tests/api_frozen.rs`: `tests/api/<version>/` holds the WIT of each
+- SDK `tests/api_frozen.rs`: `tests/api/released/` holds the WIT of the latest
   released version; every interface, type, function and world import or
-  export in it must still exist unchanged in `wit/` (rules 1–3). Copy `wit/`
-  there when releasing; there is no snapshot before the first release.
+  export in it must still exist unchanged in `wit/` (rules 1–3). Under the
+  released version `wit/` must match it exactly, so additions start with a
+  version bump. Each snapshot passed this check against the one before, so
+  one snapshot covers every release.
+- Releasing: when the `wit/` version changes, copy `wit/*.wit` over
+  `tests/api/released/` in the release commit. The release workflow refuses a
+  tag whose `wit/` version differs from the snapshot's.
 - `crates/ide-plugin/tests/api_compat.rs`: the versions agree, the SDK's copy
   matches, the version check (rules 4, 5); a simulated next-minor host (every
   import stubbed at the newer version, plus extra functions and an extra
diff --git a/plugins/official/ai-completion/dist/plugin.wasm b/plugins/official/ai-completion/dist/plugin.wasm
index 4fc5e7719..dd6b1b115 100644
Binary files a/plugins/official/ai-completion/dist/plugin.wasm and b/plugins/official/ai-completion/dist/plugin.wasm differ
diff --git a/plugins/official/ai-completion/dist/plugin.wasm.sources b/plugins/official/ai-completion/dist/plugin.wasm.sources
index d07cfcec4..5cd3a6b0d 100644
--- a/plugins/official/ai-completion/dist/plugin.wasm.sources
+++ b/plugins/official/ai-completion/dist/plugin.wasm.sources
@@ -1 +1 @@
-9ad412cb7b853d40467c67305a1126bb87910d179ecfa1c88e13d4a900367c50
+12c9f58ab05321fa3966a0179c085e2972db278adf20b917b50f30ce048aa67d
diff --git a/plugins/official/checkstyle/Cargo.lock b/plugins/official/checkstyle/Cargo.lock
index 5c3d4f38a..bc79d7916 100644
--- a/plugins/official/checkstyle/Cargo.lock
+++ b/plugins/official/checkstyle/Cargo.lock
@@ -103,7 +103,7 @@ dependencies = [
 
 [[package]]
 name = "openidea-plugin-openidea-checkstyle"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "openidea-plugin",
 ]
diff --git a/plugins/official/checkstyle/Cargo.toml b/plugins/official/checkstyle/Cargo.toml
index 2a04ad515..0ffe0337b 100644
--- a/plugins/official/checkstyle/Cargo.toml
+++ b/plugins/official/checkstyle/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "openidea-plugin-openidea-checkstyle"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2024"
 publish = false
 
diff --git a/plugins/official/checkstyle/dist/plugin.wasm b/plugins/official/checkstyle/dist/plugin.wasm
index e719df8d3..0c5b399d7 100644
Binary files a/plugins/official/checkstyle/dist/plugin.wasm and b/plugins/official/checkstyle/dist/plugin.wasm differ
diff --git a/plugins/official/checkstyle/dist/plugin.wasm.sources b/plugins/official/checkstyle/dist/plugin.wasm.sources
index f7e63f8f2..d07b95aa6 100644
--- a/plugins/official/checkstyle/dist/plugin.wasm.sources
+++ b/plugins/official/checkstyle/dist/plugin.wasm.sources
@@ -1 +1 @@
-49a3c6bf2511ba137457397203244bdfca3d6e10f62dbc7fde9473dab07f6457
+69273e1ddfd2fff9f49c11d4fbdc60a771f8e3befe440e1623c2ab97469aa250
diff --git a/plugins/official/checkstyle/plugin.toml b/plugins/official/checkstyle/plugin.toml
index 1732ad303..9c83c2b10 100644
--- a/plugins/official/checkstyle/plugin.toml
+++ b/plugins/official/checkstyle/plugin.toml
@@ -1,6 +1,6 @@
 id = "openidea.checkstyle"
 name = "Checkstyle"
-version = "0.1.0"
+version = "0.1.1"
 description = "Checks Java files with Checkstyle when you save them: problems in the editor and the Problems view, quick fixes for tabs, trailing spaces and missing final newlines."
 authors = ["OpenIDEA contributors"]
 license = "Apache-2.0"
diff --git a/plugins/official/checkstyle/src/lib.rs b/plugins/official/checkstyle/src/lib.rs
index aebf998e2..6159e7ce6 100644
--- a/plugins/official/checkstyle/src/lib.rs
+++ b/plugins/official/checkstyle/src/lib.rs
@@ -110,6 +110,26 @@ fn project_of(path: &str) -> Option<Project> {
         .max_by_key(|p| p.root().map(|r| r.len()).unwrap_or(0))
 }
 
+fn windows_path(path: &str) -> String {
+    let path = path.replace('\\', "/");
+    if let Some(rest) = path.strip_prefix("//?/UNC/") {
+        format!("//{rest}")
+    } else {
+        path.strip_prefix("//?/").unwrap_or(&path).to_owned()
+    }
+}
+
+fn report_matches_file(reported: &str, path: &str) -> bool {
+    // WASI plugins run on every host, so interpret the host's path rather than cfg(windows).
+    let drive = path.as_bytes().get(1) == Some(&b':') && path.as_bytes()[0].is_ascii_alphabetic();
+    if drive || path.starts_with("//") || path.starts_with(r"\\") {
+        let (reported, path) = (windows_path(reported), windows_path(path));
+        reported == path || path.ends_with(&reported)
+    } else {
+        reported == path || path.ends_with(reported)
+    }
+}
+
 /// The configuration for files of `project`.
 fn config_for(project: &Project) -> String {
     PROJECT_CONFIGS
@@ -138,11 +158,8 @@ impl Checkstyle {
             return Err(Error::Failed(format!("checkstyle: {}", out.stderr.lines().next().unwrap_or("no report"))));
         }
         let report = parse_report(&out.stdout);
-        let problems = report
-            .into_iter()
-            .find(|(f, _)| f == path || path.ends_with(f.as_str()))
-            .map(|(_, p)| p)
-            .unwrap_or_default();
+        let problems =
+            report.into_iter().find(|(f, _)| report_matches_file(f, path)).map(|(_, p)| p).unwrap_or_default();
         let text = project.read_file(path).unwrap_or_default();
         let diagnostics: Vec<Diagnostic> = problems.iter().map(|p| diagnostic(p, &text)).collect();
         host::publish_diagnostics(path, &diagnostics)?;
@@ -233,7 +250,7 @@ impl Plugin for Checkstyle {
 
 register_plugin!(Checkstyle, providers);
 
-#[cfg(test)]
+#[cfg(all(test, not(target_arch = "wasm32")))]
 mod tests {
     use super::*;
     use openidea_plugin::ProcessOutput;
@@ -288,6 +305,45 @@ mod tests {
         assert_eq!(actions[1].edits[0].1[0].text, "  void f() {}");
     }
 
+    #[test]
+    fn unix_report_paths_preserve_backslashes() {
+        assert!(report_matches_file("/project/A\\B.java", "/project/A\\B.java"));
+        assert!(!report_matches_file("/project/A\\B.java", "/project/A/B.java"));
+    }
+
+    #[test]
+    fn windows_reports_match_the_saved_file_and_keep_quick_fixes() {
+        for (root, reported) in [
+            ("C:/project", r"C:\project\src\A.java"),
+            ("C:/project", r"\\?\C:\project\src\A.java"),
+            ("C:/project", r"src\A.java"),
+            ("//server/share/project", r"\\server\share\project\src\A.java"),
+            ("//server/share/project", r"\\?\UNC\server\share\project\src\A.java"),
+        ] {
+            let host =
+                MockHost::install().with_capabilities(&["project.read", "events", "storage", "process:checkstyle"]);
+            host.set_project_root(Some(root));
+            host.add_file("src/A.java", "class A {\n\tint x;\n  void f() {}   \n}");
+            let xml = REPORT.replace("/project/src/A.java", reported);
+            host.on_process("checkstyle", move |_, _| {
+                Ok(ProcessOutput { status: Some(1), stdout: xml.clone(), stderr: String::new() })
+            });
+            let path = format!("{root}/src/A.java");
+            let mut plugin = Checkstyle::default();
+            plugin.handle_events(&[Event::FileSaved(path.clone())], &host.invocation());
+            assert_eq!(host.diagnostics()[&path].len(), 2, "{reported}");
+            let doc = Document {
+                path: path.clone(),
+                language: "java".into(),
+                version: 1,
+                text: "class A {\n\tint x;\n  void f() {}   \n}".into(),
+            };
+            let actions = plugin.code_actions(&doc, Range::new(Position::new(1, 0), Position::new(2, 0)));
+            assert_eq!(actions.len(), 2, "{reported}");
+            assert_eq!(actions[0].edits[0].0, path);
+        }
+    }
+
     #[test]
     fn the_projects_configuration_wins() {
         let host = MockHost::install().with_capabilities(&["project.read", "events", "storage", "process:checkstyle"]);
diff --git a/plugins/official/csv-editor/dist/plugin.wasm b/plugins/official/csv-editor/dist/plugin.wasm
index 752aba906..2b7172c52 100644
Binary files a/plugins/official/csv-editor/dist/plugin.wasm and b/plugins/official/csv-editor/dist/plugin.wasm differ
diff --git a/plugins/official/csv-editor/dist/plugin.wasm.sources b/plugins/official/csv-editor/dist/plugin.wasm.sources
index 4f6159a02..25087c64f 100644
--- a/plugins/official/csv-editor/dist/plugin.wasm.sources
+++ b/plugins/official/csv-editor/dist/plugin.wasm.sources
@@ -1 +1 @@
-c199dc52e00d3943882d532e7e6095f7b2f8d7d6026cf1ccaa685dd6300f2319
+74167252b0e306f94eb00ac9b467a5f30c373b9f15e223b21afa71c67c1dec0b
diff --git a/plugins/official/git-toolbox/dist/plugin.wasm b/plugins/official/git-toolbox/dist/plugin.wasm
index 5e26ce4e1..c00455582 100644
Binary files a/plugins/official/git-toolbox/dist/plugin.wasm and b/plugins/official/git-toolbox/dist/plugin.wasm differ
diff --git a/plugins/official/git-toolbox/dist/plugin.wasm.sources b/plugins/official/git-toolbox/dist/plugin.wasm.sources
index 0131a6b6f..b2bdee8e8 100644
--- a/plugins/official/git-toolbox/dist/plugin.wasm.sources
+++ b/plugins/official/git-toolbox/dist/plugin.wasm.sources
@@ -1 +1 @@
-6047be5eeaa1330d7aa1f182e88ae2f352f244829ad9a01fdc3a2a081bdca95d
+66e7f43eaf7bbadf1c5c817c6ce8da3adca0543ce5e12550440b4039b235581d
diff --git a/plugins/official/graphviz/dist/plugin.wasm b/plugins/official/graphviz/dist/plugin.wasm
index 912edbd6c..d74e615fe 100644
Binary files a/plugins/official/graphviz/dist/plugin.wasm and b/plugins/official/graphviz/dist/plugin.wasm differ
diff --git a/plugins/official/graphviz/dist/plugin.wasm.sources b/plugins/official/graphviz/dist/plugin.wasm.sources
index 1657b2d52..5c61c4c01 100644
--- a/plugins/official/graphviz/dist/plugin.wasm.sources
+++ b/plugins/official/graphviz/dist/plugin.wasm.sources
@@ -1 +1 @@
-7a3ee410d228d1e39155aa042237d222d23d7f5a45e261086cffc45c6ee1ad32
+04cd70714c6bac560783492b3bd31d22f7056b9d8809df14163be935785dd114
diff --git a/plugins/official/key-promoter/dist/plugin.wasm b/plugins/official/key-promoter/dist/plugin.wasm
index 99400b9b3..8d431a4f7 100644
Binary files a/plugins/official/key-promoter/dist/plugin.wasm and b/plugins/official/key-promoter/dist/plugin.wasm differ
diff --git a/plugins/official/key-promoter/dist/plugin.wasm.sources b/plugins/official/key-promoter/dist/plugin.wasm.sources
index 84b4dfaae..a824dc2ab 100644
--- a/plugins/official/key-promoter/dist/plugin.wasm.sources
+++ b/plugins/official/key-promoter/dist/plugin.wasm.sources
@@ -1 +1 @@
-7658a95eb9fc27468cae4b1d20e3b5ab299fde478e07f69ab0fdb4cc10caf11d
+674f439626f08e931842c0c108a57c899ea38d2b5b2de38debd3b4b46feb5777
diff --git a/plugins/official/license-header/dist/plugin.wasm b/plugins/official/license-header/dist/plugin.wasm
index fdcbdd184..ecdc7cca6 100644
Binary files a/plugins/official/license-header/dist/plugin.wasm and b/plugins/official/license-header/dist/plugin.wasm differ
diff --git a/plugins/official/license-header/dist/plugin.wasm.sources b/plugins/official/license-header/dist/plugin.wasm.sources
index e5ee06b9e..b89a5e83f 100644
--- a/plugins/official/license-header/dist/plugin.wasm.sources
+++ b/plugins/official/license-header/dist/plugin.wasm.sources
@@ -1 +1 @@
-227a30ef0028f167a20825bdd775b15392161e641f6c68030e01d0c79e263bb5
+ee40771fe778d4af1f762c1512155ea375ee3ed238390c65a5461b077fed6f8b
diff --git a/plugins/official/mybatis/dist/plugin.wasm b/plugins/official/mybatis/dist/plugin.wasm
index b31649e93..5a9d2d01d 100644
Binary files a/plugins/official/mybatis/dist/plugin.wasm and b/plugins/official/mybatis/dist/plugin.wasm differ
diff --git a/plugins/official/mybatis/dist/plugin.wasm.sources b/plugins/official/mybatis/dist/plugin.wasm.sources
index 34acc2672..0d4ec6985 100644
--- a/plugins/official/mybatis/dist/plugin.wasm.sources
+++ b/plugins/official/mybatis/dist/plugin.wasm.sources
@@ -1 +1 @@
-046f769822102de0d4ecec99ad41027cb792941065226716f38a6e64c50ff364
+b9cc6408738acd7a89ff76632d91ec49680c7a5ff6bee292efa77d182003ec25
diff --git a/plugins/official/regex-tester/dist/plugin.wasm b/plugins/official/regex-tester/dist/plugin.wasm
index a8e10a846..e9cec69d8 100644
Binary files a/plugins/official/regex-tester/dist/plugin.wasm and b/plugins/official/regex-tester/dist/plugin.wasm differ
diff --git a/plugins/official/regex-tester/dist/plugin.wasm.sources b/plugins/official/regex-tester/dist/plugin.wasm.sources
index df4b262ac..a727fdce8 100644
--- a/plugins/official/regex-tester/dist/plugin.wasm.sources
+++ b/plugins/official/regex-tester/dist/plugin.wasm.sources
@@ -1 +1 @@
-0b9c3572390a3caab7d47f9b975439f8dde3feff6b9044579d99b8334ac2a692
+6c9c35547a7ce1c240be83bbb30418a28ab8e2e4034401205e35ec2dee87abbf
diff --git a/plugins/official/solidity/dist/plugin.wasm b/plugins/official/solidity/dist/plugin.wasm
index cef826bba..7a36721c8 100644
Binary files a/plugins/official/solidity/dist/plugin.wasm and b/plugins/official/solidity/dist/plugin.wasm differ
diff --git a/plugins/official/solidity/dist/plugin.wasm.sources b/plugins/official/solidity/dist/plugin.wasm.sources
index 09d619246..937d87db1 100644
--- a/plugins/official/solidity/dist/plugin.wasm.sources
+++ b/plugins/official/solidity/dist/plugin.wasm.sources
@@ -1 +1 @@
-0af62bcd4583d126a616cafbf2ddc80f039a3ead2b5dcb7144222b0ebc673432
+56af2a764333e739d53fb5c8346835b4796cf76611c36b4685a428b49cc4eae2
diff --git a/plugins/official/string-tools/dist/plugin.wasm b/plugins/official/string-tools/dist/plugin.wasm
index 3ae03a508..204171108 100644
Binary files a/plugins/official/string-tools/dist/plugin.wasm and b/plugins/official/string-tools/dist/plugin.wasm differ
diff --git a/plugins/official/string-tools/dist/plugin.wasm.sources b/plugins/official/string-tools/dist/plugin.wasm.sources
index c511466f2..a934a4a48 100644
--- a/plugins/official/string-tools/dist/plugin.wasm.sources
+++ b/plugins/official/string-tools/dist/plugin.wasm.sources
@@ -1 +1 @@
-24ef150beefb05622212228e1c44cb487fffe6526776762d713f3ebdf4c02ac0
+ac745c20866ed959252778116af068d7264187a53df64e2de090522b7ba5b722
diff --git a/scripts/theme/theme.test.ts b/scripts/theme/theme.test.ts
index 404d99096..b70c6d80b 100644
--- a/scripts/theme/theme.test.ts
+++ b/scripts/theme/theme.test.ts
@@ -220,11 +220,6 @@ describe("IntelliJ theme import", () => {
       ],
     });
     expect(pkg.id).toBe("intellij.com-example-deepsea");
-    expect(pkg.themes).toEqual([
-      { id: "deep-sea", sourceId: "deep-sea-id", name: "Deep Sea" },
-      { id: "deep-sea-2", sourceId: "copy-id", name: "Deep Sea" },
-      { id: "shallow", sourceId: "light-id", name: "Shallow" },
-    ]);
     expect(pkg.files.map((f) => f.path)).toEqual([
       "plugin.toml",
       "themes/deep-sea.theme.json",
diff --git a/sdk/rust/openidea-plugin/src/host.rs b/sdk/rust/openidea-plugin/src/host.rs
index 88cef0e32..6b93a1e7e 100644
--- a/sdk/rust/openidea-plugin/src/host.rs
+++ b/sdk/rust/openidea-plugin/src/host.rs
@@ -73,6 +73,14 @@ mod imp {
         wit::ui::remove_status_item(id)
     }
 
+    pub fn copy_to_clipboard(text: &str) -> Result<(), Error> {
+        wit::ui::copy_to_clipboard(text).map_err(error)
+    }
+
+    pub fn open_url(url: &str) -> Result<(), Error> {
+        wit::ui::open_url(url).map_err(error)
+    }
+
     pub fn storage_get(key: &str) -> Result<Option<String>, Error> {
         wit::storage::get(key).map_err(error)
     }
@@ -152,6 +160,10 @@ mod imp {
         wit::vcs::fetch(p).map_err(error)
     }
 
+    pub fn vcs_remotes(p: &ProjectRes) -> Result<Vec<(String, String)>, Error> {
+        wit::vcs::remotes(p).map_err(error)
+    }
+
     pub fn subscribe(k: EventKind) -> Result<(), Error> {
         wit::events::subscribe(k.name()).map_err(error)
     }
@@ -339,6 +351,11 @@ impl Project {
         imp::vcs_status(&self.inner)
     }
 
+    /// Configured remotes (`(name, fetch_url)`), in order. Needs `vcs.read`.
+    pub fn vcs_remotes(&self) -> Result<Vec<(String, String)>, Error> {
+        imp::vcs_remotes(&self.inner)
+    }
+
     /// Fetches all remotes. Needs `vcs.write`; long-running, so call it in a [`Task`].
     pub fn vcs_fetch(&self) -> Result<(), Error> {
         imp::vcs_fetch(&self.inner)
@@ -528,6 +545,16 @@ pub fn remove_status_item(id: &str) {
     imp::remove_status_item(id)
 }
 
+/// Copies `text` to the system clipboard. Needs `clipboard`.
+pub fn copy_to_clipboard(text: &str) -> Result<(), Error> {
+    imp::copy_to_clipboard(text)
+}
+
+/// Opens an `http://` or `https://` URL in the user's default browser.
+pub fn open_url(url: &str) -> Result<(), Error> {
+    imp::open_url(url)
+}
+
 /// Delivers `kind` events to [`crate::Plugin::handle_events`] for the rest of
 /// the session (also after the instance is reclaimed: an event activates the
 /// plugin again). Needs `events` (`events.input` for `ActionPerformed`).
diff --git a/sdk/rust/openidea-plugin/src/lib.rs b/sdk/rust/openidea-plugin/src/lib.rs
index 57aebe86e..1172d78f5 100644
--- a/sdk/rust/openidea-plugin/src/lib.rs
+++ b/sdk/rust/openidea-plugin/src/lib.rs
@@ -89,7 +89,7 @@ pub mod providers_bindings {
         export_macro_name: "__export_editor_providers_world",
         default_bindings_module: "openidea_plugin::providers_bindings",
         with: {
-            "openidea:plugin/types@1.0.0": crate::bindings::openidea::plugin::types,
+            "openidea:plugin/types@1.1.0": crate::bindings::openidea::plugin::types,
         },
     });
 }
@@ -106,16 +106,16 @@ pub mod views_bindings {
         export_macro_name: "__export_views_world",
         default_bindings_module: "openidea_plugin::views_bindings",
         with: {
-            "openidea:plugin/types@1.0.0": crate::bindings::openidea::plugin::types,
-            "openidea:plugin/workspace@1.0.0": crate::bindings::openidea::plugin::workspace,
-            "openidea:plugin/editor@1.0.0": crate::bindings::openidea::plugin::editor,
-            "openidea:plugin/invocation@1.0.0": crate::bindings::openidea::plugin::invocation,
+            "openidea:plugin/types@1.1.0": crate::bindings::openidea::plugin::types,
+            "openidea:plugin/workspace@1.1.0": crate::bindings::openidea::plugin::workspace,
+            "openidea:plugin/editor@1.1.0": crate::bindings::openidea::plugin::editor,
+            "openidea:plugin/invocation@1.1.0": crate::bindings::openidea::plugin::invocation,
         },
     });
 }
 
 /// The plugin API version this SDK targets.
-pub const API_VERSION: &str = "1.0";
+pub const API_VERSION: &str = "1.1";
 
 /// A plugin. One instance lives as long as the plugin's Wasm instance (until
 /// it is disabled, crashes or is reclaimed when idle).
diff --git a/sdk/rust/openidea-plugin/src/mock.rs b/sdk/rust/openidea-plugin/src/mock.rs
index 334da48fb..a011569eb 100644
--- a/sdk/rust/openidea-plugin/src/mock.rs
+++ b/sdk/rust/openidea-plugin/src/mock.rs
@@ -63,8 +63,11 @@ struct State {
     subscriptions: BTreeSet<EventKind>,
     tasks: Vec<MockTask>,
     vcs: Option<RepositoryStatus>,
+    remotes: Vec<(String, String)>,
     fetches: u32,
     fetch_error: Option<Error>,
+    clipboard: Option<String>,
+    opened_urls: Vec<String>,
     diagnostics: BTreeMap<String, Vec<Diagnostic>>,
     secrets: BTreeMap<String, String>,
     net: Option<NetHandler>,
@@ -96,8 +99,17 @@ pub struct MockHost {
 }
 
 /// Every capability a plugin can hold, except `process:`/`net:`/`fs.read:`.
-const ALL: &[&str] =
-    &["project.read", "editor.read", "editor.write", "vcs.read", "vcs.write", "storage", "events", "events.input"];
+const ALL: &[&str] = &[
+    "project.read",
+    "editor.read",
+    "editor.write",
+    "vcs.read",
+    "vcs.write",
+    "storage",
+    "events",
+    "events.input",
+    "clipboard",
+];
 
 impl MockHost {
     /// Installs a mock granting the usual capabilities, with project `/project`.
@@ -197,6 +209,21 @@ impl MockHost {
         self.state.borrow_mut().vcs = status;
     }
 
+    /// Remotes `vcs-remotes` returns for every project.
+    pub fn set_vcs_remotes(&self, remotes: &[(&str, &str)]) {
+        self.state.borrow_mut().remotes = remotes.iter().map(|&(n, u)| (n.to_owned(), u.to_owned())).collect();
+    }
+
+    /// Last text copied with [`crate::host::copy_to_clipboard`].
+    pub fn clipboard(&self) -> Option<String> {
+        self.state.borrow().clipboard.clone()
+    }
+
+    /// URLs opened with [`crate::host::open_url`], in order.
+    pub fn opened_urls(&self) -> Vec<String> {
+        self.state.borrow().opened_urls.clone()
+    }
+
     /// Makes `vcs-fetch` fail.
     pub fn fail_fetch(&self, error: Option<Error>) {
         self.state.borrow_mut().fetch_error = error;
@@ -350,6 +377,25 @@ pub mod current {
         with(|s| s.status.remove(id));
     }
 
+    pub fn copy_to_clipboard(text: &str) -> Result<(), Error> {
+        with(|s| {
+            require(s, "clipboard")?;
+            s.clipboard = Some(text.to_owned());
+            Ok(())
+        })
+    }
+
+    pub fn open_url(url: &str) -> Result<(), Error> {
+        let trimmed = url.trim();
+        if !(trimmed.starts_with("https://") || trimmed.starts_with("http://")) {
+            return Err(Error::Invalid(format!("{url:?}: expected an http:// or https:// URL")));
+        }
+        with(|s| {
+            s.opened_urls.push(trimmed.to_owned());
+            Ok(())
+        })
+    }
+
     pub fn storage_get(key: &str) -> Result<Option<String>, Error> {
         with(|s| {
             require(s, "storage")?;
@@ -496,6 +542,13 @@ pub mod current {
         })
     }
 
+    pub fn vcs_remotes(_: &ProjectRes) -> Result<Vec<(String, String)>, Error> {
+        with(|s| {
+            require(s, "vcs.read")?;
+            Ok(s.remotes.clone())
+        })
+    }
+
     pub fn subscribe(kind: EventKind) -> Result<(), Error> {
         with(|s| {
             let cap = match kind {
@@ -680,6 +733,13 @@ mod tests {
         assert_eq!(host::storage::keys("").unwrap(), ["k"]);
         host::set_status_item("s", &StatusItem { text: "x".into(), tooltip: None, command: None });
         assert_eq!(mock.status_items()["s"].text, "x");
+        mock.set_vcs_remotes(&[("origin", "git@github.com:o/r.git")]);
+        assert_eq!(project.vcs_remotes().unwrap(), [("origin".into(), "git@github.com:o/r.git".into())]);
+        host::copy_to_clipboard("copied").unwrap();
+        assert_eq!(mock.clipboard().as_deref(), Some("copied"));
+        host::open_url("https://example.com/a").unwrap();
+        assert_eq!(mock.opened_urls(), ["https://example.com/a"]);
+        assert!(matches!(host::open_url("file:///etc/passwd"), Err(Error::Invalid(_))));
         {
             let task = host::begin_task("Work", true);
             task.report(1, Some(2), None);
@@ -709,6 +769,8 @@ mod tests {
         assert_eq!(editor.apply_edits(1, &[]), Err(Error::Denied("editor.write".into())));
         assert_eq!(host::storage::get("k"), Err(Error::Denied("storage".into())));
         assert_eq!(host::subscribe(EventKind::ActionPerformed), Err(Error::Denied("events.input".into())));
+        assert_eq!(mock.invocation().project().unwrap().vcs_remotes(), Err(Error::Denied("vcs.read".into())));
+        assert_eq!(host::copy_to_clipboard("x"), Err(Error::Denied("clipboard".into())));
     }
 
     #[test]
diff --git a/sdk/rust/openidea-plugin/tests/api/released/events.wit b/sdk/rust/openidea-plugin/tests/api/released/events.wit
new file mode 100644
index 000000000..7da95eac5
--- /dev/null
+++ b/sdk/rust/openidea-plugin/tests/api/released/events.wit
@@ -0,0 +1,54 @@
+package openidea:plugin@1.1.0;
+
+/// Workbench events, delivered in batches to `event-handler.handle`.
+interface events {
+    use types.{error, extension};
+
+    record action-performed {
+        /// Action id (`editor.duplicate-line`).
+        action: string,
+        title: string,
+        /// How the user started it: `keyboard`, `menu`, `toolbar`,
+        /// `context-menu`, `search` or `other` (more may be added).
+        source: string,
+        /// Its keyboard shortcut, when it has one (`Ctrl+D`).
+        shortcut: option<string>,
+    }
+
+    variant event {
+        file-opened(string),
+        file-saved(string),
+        editor-focused(option<string>),
+        action-performed(action-performed),
+        vcs-changed(string),
+        scheduled,
+        /// A kind added after 1.0 (subscribed to by its name).
+        other(extension),
+    }
+
+    /// Delivers `kind` events from now on, for the rest of the session (also
+    /// across idle reclaim: an event activates the plugin again). Declare
+    /// `activation = ["on-event:<kind>"]` to get them before first use.
+    /// Kinds: `file-opened`, `file-saved`, `editor-focused` (the focused editor
+    /// changed), `vcs-changed` (a repository's state changed: commit,
+    /// checkout, fetch…), `action-performed` (an IDE action ran) and
+    /// `scheduled` (the `on-schedule` period elapsed); later IDEs add more,
+    /// and an IDE that doesn't know one fails with `invalid`.
+    /// Requires `events` (`events.input` for `action-performed`).
+    subscribe: func(kind: string) -> result<_, error>;
+    unsubscribe: func(kind: string);
+}
+
+/// Long-running work with a progress indicator. While a task is open, the
+/// call that began it may run for the background budget (60 s) instead of 5 s.
+interface tasks {
+    resource task {
+        /// `done` of `total` units (`none`: indeterminate), with a short status.
+        report: func(done: u32, total: option<u32>, message: option<string>);
+        /// The user cancelled it: stop soon and return.
+        is-cancelled: func() -> bool;
+    }
+
+    /// Starts a task shown in the status bar; dropping it ends it.
+    begin: func(title: string, cancellable: bool) -> task;
+}
diff --git a/sdk/rust/openidea-plugin/tests/api/released/exports.wit b/sdk/rust/openidea-plugin/tests/api/released/exports.wit
new file mode 100644
index 000000000..808377432
--- /dev/null
+++ b/sdk/rust/openidea-plugin/tests/api/released/exports.wit
@@ -0,0 +1,75 @@
+package openidea:plugin@1.1.0;
+
+interface lifecycle {
+    use types.{context, error};
+
+    /// Called once after the instance is created: subscribe to events and
+    /// restore state from `storage`. Contributions (commands, languages,
+    /// themes, …) are declared in plugin.toml, not registered here.
+    /// An error fails the activation (shown on the plugin's page).
+    activate: func(ctx: context) -> result<_, error>;
+    /// Called before the instance is dropped (disable, uninstall, idle reclaim).
+    deactivate: func();
+}
+
+interface commands {
+    use types.{error};
+    use invocation.{invocation};
+
+    /// Runs one of the plugin's commands. Returns an optional message.
+    /// `cancelled` (the user gave up) and `denied` (a capability is missing)
+    /// are not counted as the plugin failing.
+    run: func(id: string, ctx: borrow<invocation>, arg: option<string>) -> result<option<string>, error>;
+}
+
+interface event-handler {
+    use events.{event};
+    use invocation.{invocation};
+
+    /// A batch of subscribed events, oldest first, from one window (`ctx`).
+    handle: func(events: list<event>, ctx: borrow<invocation>);
+}
+
+/// Optional export (world `plugin-syntax`): syntax of the plugin's own
+/// languages, for languages the IDE has no grammar for. The IDE calls it
+/// with the whole document; results are flat. Offsets are UTF-8 byte offsets
+/// into `text` (the IDE converts them); lines are 0-based.
+interface syntax-provider {
+    /// One highlighted range. `kind` is a highlight category: keyword, string,
+    /// string-special, escape, regexp, atom, number, constant, comment,
+    /// doc-comment, function, function-call, builtin, type, namespace,
+    /// variable, self-variable, property, attribute, macro, label, tag,
+    /// operator, punctuation. Unknown kinds are ignored; ranges must be
+    /// sorted and not overlap.
+    record token {
+        start: u32,
+        end: u32,
+        kind: string,
+    }
+
+    /// A symbol of the structure view. `parent` is the index of the enclosing
+    /// symbol in the same list (which must come first).
+    record symbol {
+        name: string,
+        detail: option<string>,
+        /// class, interface, struct, enum, function, method, constructor,
+        /// field, property, variable, constant, module, namespace, event, …
+        kind: string,
+        start: u32,
+        end: u32,
+        name-start: u32,
+        name-end: u32,
+        parent: option<u32>,
+    }
+
+    /// A foldable line range. `kind`: region, comment or imports.
+    record fold {
+        start-line: u32,
+        end-line: u32,
+        kind: string,
+    }
+
+    highlights: func(language: string, text: string) -> list<token>;
+    outline: func(language: string, text: string) -> list<symbol>;
+    folding: func(language: string, text: string) -> list<fold>;
+}
diff --git a/sdk/rust/openidea-plugin/tests/api/released/host.wit b/sdk/rust/openidea-plugin/tests/api/released/host.wit
new file mode 100644
index 000000000..c7ac7f916
--- /dev/null
+++ b/sdk/rust/openidea-plugin/tests/api/released/host.wit
@@ -0,0 +1,42 @@
+package openidea:plugin@1.1.0;
+
+/// Writes to the IDE log, tagged with the plugin id.
+interface log {
+    use types.{log-level};
+
+    log: func(level: log-level, message: string);
+}
+
+interface ui {
+    use types.{error, notification-level};
+
+    record status-item {
+        text: string,
+        tooltip: option<string>,
+        /// One of the plugin's commands, run when the item is clicked.
+        command: option<string>,
+    }
+
+    /// Shows a notification balloon in the window the current command or
+    /// event came from (every window when there is none).
+    show-notification: func(level: notification-level, title: string, body: string);
+    /// Shows or updates the plugin's status bar item `id` in every window.
+    set-status-item: func(id: string, item: status-item);
+    remove-status-item: func(id: string);
+    /// Copies `text` to the system clipboard. Requires `clipboard`.
+    copy-to-clipboard: func(text: string) -> result<_, error>;
+    /// Opens an `http://` or `https://` URL in the user's default browser.
+    open-url: func(url: string) -> result<_, error>;
+}
+
+/// Persistent key-value storage of the plugin (survives restarts and idle
+/// reclaim; instance memory does not). Requires `storage`. At most 1 MiB.
+interface storage {
+    use types.{error};
+
+    get: func(key: string) -> result<option<string>, error>;
+    set: func(key: string, value: string) -> result<_, error>;
+    delete: func(key: string) -> result<_, error>;
+    /// Keys starting with `prefix`, sorted.
+    keys: func(prefix: string) -> result<list<string>, error>;
+}
diff --git a/sdk/rust/openidea-plugin/tests/api/released/io.wit b/sdk/rust/openidea-plugin/tests/api/released/io.wit
new file mode 100644
index 000000000..b93ea079e
--- /dev/null
+++ b/sdk/rust/openidea-plugin/tests/api/released/io.wit
@@ -0,0 +1,96 @@
+package openidea:plugin@1.1.0;
+
+/// Problems in files, shown in the editor and the Problems view.
+interface diagnostics {
+    use types.{error, range, location};
+
+    enum severity {
+        error,
+        warning,
+        info,
+        hint,
+    }
+
+    /// Another place that explains a diagnostic (the earlier declaration, say).
+    record related-information {
+        location: location,
+        message: string,
+    }
+
+    record diagnostic {
+        range: range,
+        severity: severity,
+        message: string,
+        /// Rule or check id (`LineLength`).
+        code: option<string>,
+        /// The tool that found it, when not the plugin itself (`checkstyle`).
+        source: option<string>,
+        /// `unnecessary` (shown faded) and `deprecated` (struck through); unknown ones are ignored.
+        tags: list<string>,
+        related: list<related-information>,
+    }
+
+    /// Replaces the plugin's diagnostics for the file at `path` (absolute, in
+    /// an open project); an empty list clears them. Requires `project.read`.
+    publish: func(path: string, diagnostics: list<diagnostic>) -> result<_, error>;
+}
+
+/// HTTP(S) to the hosts granted with `net:<host>`.
+interface net {
+    use types.{error};
+
+    record header {
+        name: string,
+        value: string,
+    }
+
+    record request {
+        method: string,
+        /// `https://…`; plain `http://` only to `localhost` / `127.0.0.1`.
+        url: string,
+        /// `{{secret:<name>}}` in a value is replaced by the plugin's secret
+        /// `name` on the way out (requires `secrets`); the plugin never sees it.
+        headers: list<header>,
+        body: option<list<u8>>,
+        /// Default 30 s; the call's own budget applies too.
+        timeout-ms: option<u32>,
+    }
+
+    record response {
+        status: u16,
+        headers: list<header>,
+        /// At most 8 MiB.
+        body: list<u8>,
+    }
+
+    /// Fails with `denied` for a host the plugin may not reach, `cancelled`
+    /// when a newer request replaced the call or the user cancelled.
+    fetch: func(req: request) -> result<response, error>;
+}
+
+/// Secrets the user stored for the plugin (Settings › Plugins, kept in the
+/// OS keychain). Plugins only use them through `{{secret:<name>}}` in
+/// `net` requests. Requires `secrets`.
+interface secrets {
+    is-set: func(name: string) -> bool;
+}
+
+/// One-off runs of programs granted with `process:<program>` (the file the
+/// user approved, checked before every run).
+interface process {
+    use types.{error};
+    use workspace.{project};
+
+    record output {
+        /// `none` when killed by a signal.
+        status: option<s32>,
+        /// At most 4 MiB each (the rest is dropped).
+        stdout: string,
+        stderr: string,
+    }
+
+    /// Runs `program` with `args` in `cwd`'s root (else the plugin's data
+    /// directory) and waits; cancelled with the task or call. Call it inside
+    /// a task for anything slow.
+    run: func(program: string, args: list<string>, cwd: option<borrow<project>>, stdin: option<string>) -> result<output, error>;
+}
diff --git a/sdk/rust/openidea-plugin/tests/api/released/plugin.wit b/sdk/rust/openidea-plugin/tests/api/released/plugin.wit
new file mode 100644
index 000000000..e9fc0ac85
--- /dev/null
+++ b/sdk/rust/openidea-plugin/tests/api/released/plugin.wit
@@ -0,0 +1,67 @@
+/// OpenIDEA plugin API, version 1.0. Once released, 1.x only adds (new
+/// interfaces, new optional exports; plugins/README.md, "Evolving the plugin
+/// API"); a 2.0 keeps 1.0 running through an adapter in the host.
+///
+/// A plugin is a WebAssembly component targeting the `plugin` world (or
+/// `plugin-syntax`). It runs sandboxed: no filesystem, network, environment
+/// or processes beyond WASI's clocks and randomness; everything else goes
+/// through the imports below, gated by the capabilities granted in
+/// `plugin.toml` (a missing one returns `error::denied`).
+package openidea:plugin@1.1.0;
+
+world plugin {
+    import log;
+    import ui;
+    import storage;
+    import workspace;
+    import editor;
+    import invocation;
+    import vcs;
+    import events;
+    import tasks;
+    import diagnostics;
+    import net;
+    import secrets;
+    import process;
+    import views;
+    import settings;
+
+    export lifecycle;
+    export commands;
+    export event-handler;
+}
+
+/// A plugin that also provides syntax for its languages.
+world plugin-syntax {
+    include plugin;
+    export syntax-provider;
+}
+
+/// A plugin with editor providers (`[[contributes.providers]]`).
+world plugin-providers {
+    include plugin;
+    export providers;
+}
+
+/// A plugin with views or custom editors (`[[contributes.views]]`,
+/// `[[contributes.custom-editors]]`).
+world plugin-views {
+    include plugin;
+    export view-provider;
+}
+
+/// Only the `syntax-provider` export: guests generate it next to `plugin`
+/// (the component tools merge both into one component).
+world syntax {
+    export syntax-provider;
+}
+
+/// Only the `providers` export, generated next to `plugin` like `syntax`.
+world editor-providers {
+    export providers;
+}
+
+/// Only the `view-provider` export, generated next to `plugin` like `syntax`.
+world views-provider {
+    export view-provider;
+}
diff --git a/sdk/rust/openidea-plugin/tests/api/released/providers.wit b/sdk/rust/openidea-plugin/tests/api/released/providers.wit
new file mode 100644
index 000000000..17c1123a8
--- /dev/null
+++ b/sdk/rust/openidea-plugin/tests/api/released/providers.wit
@@ -0,0 +1,81 @@
+package openidea:plugin@1.1.0;
+
+/// Editor features a plugin provides for the languages it declares under
+/// `[[contributes.providers]]` (the host calls only declared kinds). They run
+/// on the editing path: a result later than ~50 ms is dropped, a call still
+/// running at 500 ms is interrupted.
+interface providers {
+    use types.{error, position, range, text-edit, location};
+
+    /// The document a request is about.
+    record document {
+        path: string,
+        language: string,
+        version: u64,
+        text: string,
+    }
+
+    record completion-item {
+        label: string,
+        detail: option<string>,
+        /// Icon and sort group: text, method, function, constructor, field,
+        /// variable, class, interface, module, property, unit, value, enum,
+        /// keyword, snippet, color, file, reference, folder, enum-member,
+        /// constant, struct, event, operator or type-parameter. Unknown kinds
+        /// show no icon.
+        kind: option<string>,
+        /// With `snippet`, tab stops and placeholders (`$1`, `${1:name}`, `$0`).
+        insert-text: string,
+        snippet: bool,
+        /// Replaced on accept; `none`: the word at the caret.
+        replace: option<range>,
+        sort-text: option<string>,
+        /// Matched against what was typed instead of `label`.
+        filter-text: option<string>,
+        documentation: option<string>,
+        /// Applied with the item elsewhere in the document (an import).
+        additional-edits: list<text-edit>,
+    }
+
+    record inline-suggestion {
+        insert-text: string,
+        /// Replaced range; `none` inserts at the caret.
+        replace: option<range>,
+    }
+
+    record file-edit {
+        path: string,
+        edits: list<text-edit>,
+    }
+
+    record code-action {
+        title: string,
+        /// `quickfix`, `refactor`, …
+        kind: option<string>,
+        preferred: bool,
+        edits: list<file-edit>,
+        /// The plugin's own reference: with it and no `edits`, the edits are
+        /// computed by `resolve-code-action` once the user picks the action.
+        data: option<string>,
+    }
+
+    record line-marker {
+        line: u32,
+        /// Gutter icon: `navigate` (default), `implemented`, `implementing`, `run`.
+        icon: option<string>,
+        tooltip: string,
+        /// Opened on click.
+        target: option<location>,
+    }
+
+    completion: func(doc: document, at: position, trigger: option<string>) -> list<completion-item>;
+    /// Ghost text at the caret (typing replaces an older request: it is cancelled).
+    inline-completion: func(doc: document, at: position) -> option<inline-suggestion>;
+    /// Actions for `selection` (quick fixes for the plugin's own diagnostics).
+    code-actions: func(doc: document, selection: range) -> list<code-action>;
+    /// The edits of an action `code-actions` returned with `data`, when the
+    /// user picks it (the command budget applies, not the editor's 50 ms).
+    resolve-code-action: func(doc: document, action: code-action) -> result<code-action, error>;
+    definition: func(doc: document, at: position) -> list<location>;
+    line-markers: func(doc: document) -> list<line-marker>;
+}
diff --git a/sdk/rust/openidea-plugin/tests/api/released/types.wit b/sdk/rust/openidea-plugin/tests/api/released/types.wit
new file mode 100644
index 000000000..de35cadf6
--- /dev/null
+++ b/sdk/rust/openidea-plugin/tests/api/released/types.wit
@@ -0,0 +1,73 @@
+package openidea:plugin@1.1.0;
+
+/// Shared types. Positions are 0-based lines and UTF-16 code unit columns,
+/// as in the editor and LSP.
+interface types {
+    /// Why a host call failed. A capability that is not granted is reported
+    /// as `denied`, so the plugin can degrade (0.1 trapped instead).
+    variant error {
+        /// Not granted; the payload names the capability (`editor.write`).
+        denied(string),
+        /// The document changed since the version the edit was made for.
+        stale,
+        not-found(string),
+        invalid(string),
+        /// Cancelled by the user, or the plugin is being stopped.
+        cancelled,
+        failed(string),
+    }
+
+    enum log-level {
+        trace,
+        debug,
+        info,
+        warn,
+        error,
+    }
+
+    enum notification-level {
+        info,
+        warning,
+        error,
+    }
+
+    record position {
+        line: u32,
+        character: u32,
+    }
+
+    record range {
+        start: position,
+        end: position,
+    }
+
+    record text-edit {
+        range: range,
+        text: string,
+    }
+
+    /// A range in a file (absolute path).
+    record location {
+        path: string,
+        range: range,
+    }
+
+    /// A case added after 1.0, carried by the `other` case of a variant that
+    /// grows (events, view bodies, view events, form fields): its kind and its
+    /// data as JSON. Whoever doesn't know the kind ignores it or shows a
+    /// fallback; the SDKs decode the kinds they know.
+    record extension {
+        kind: string,
+        data: string,
+    }
+
+    /// Passed to `lifecycle.activate`.
+    record context {
+        plugin-id: string,
+        plugin-version: string,
+        /// Version of this API the host implements, e.g. "1.0".
+        api-version: string,
+        /// Capabilities granted to the plugin (`editor.write`, `process:git`, …).
+        capabilities: list<string>,
+    }
+}
diff --git a/sdk/rust/openidea-plugin/tests/api/released/views.wit b/sdk/rust/openidea-plugin/tests/api/released/views.wit
new file mode 100644
index 000000000..8a67e222e
--- /dev/null
+++ b/sdk/rust/openidea-plugin/tests/api/released/views.wit
@@ -0,0 +1,158 @@
+package openidea:plugin@1.1.0;
+
+/// Declarative views: tool windows declared
+/// under `[[contributes.views]]` and custom editors under
+/// `[[contributes.customEditors]]`. The plugin describes what to show; the
+/// IDE renders it with its own components (theme, keyboard, accessibility)
+/// and sends the user's actions back as `view-event`s. Nothing of the plugin
+/// runs in the WebView, except a `html` body, which is shown in a sandboxed
+/// frame that can only exchange messages with the plugin.
+interface view-types {
+    use types.{extension};
+
+    record button {
+        id: string,
+        label: string,
+        /// An IDE icon name (`refresh`, `add`, `remove`, `run`, …).
+        icon: option<string>,
+        enabled: bool,
+    }
+
+    /// A tree node; `parent` is the key of an earlier item (none: a root).
+    record tree-item {
+        key: string,
+        parent: option<string>,
+        label: string,
+        icon: option<string>,
+        /// Grey text after the label.
+        detail: option<string>,
+        /// Shows an expander even before its children are known
+        /// (`expand` asks for them).
+        expandable: bool,
+        expanded: bool,
+    }
+
+    record list-item {
+        key: string,
+        label: string,
+        icon: option<string>,
+        detail: option<string>,
+    }
+
+    variant field-value {
+        text(string),
+        multiline(string),
+        checkbox(bool),
+        /// The options and the chosen one.
+        choice(tuple<list<string>, string>),
+        /// A field type added after 1.0 (an IDE that doesn't know it leaves it out).
+        other(extension),
+    }
+
+    record field {
+        key: string,
+        label: string,
+        value: field-value,
+    }
+
+    /// Rows `first-row`..`first-row + len(rows)` of `total-rows`: the IDE
+    /// asks for the rows it shows (`viewport`), so large tables stay cheap.
+    record table {
+        columns: list<string>,
+        total-rows: u32,
+        first-row: u32,
+        rows: list<list<string>>,
+        editable: bool,
+    }
+
+    variant body {
+        /// A centred message (empty state, errors).
+        message(string),
+        tree(list<tree-item>),
+        %list(list<list-item>),
+        form(list<field>),
+        table(table),
+        /// HTML shown in a sandboxed frame: no scripts from elsewhere, no
+        /// network, no IDE API. Its script talks to the plugin with
+        /// `openidea.postMessage(text)` / `openidea.onMessage(fn)`.
+        html(string),
+        /// A body added after 1.0; an IDE that doesn't know it says it needs updating.
+        other(extension),
+    }
+
+    record view {
+        toolbar: list<button>,
+        body: body,
+        /// A line below the body (counts, last refresh…).
+        status: option<string>,
+    }
+
+    /// The table rows the IDE shows.
+    record viewport {
+        first-row: u32,
+        rows: u32,
+    }
+
+    record cell-edit {
+        row: u32,
+        column: u32,
+        value: string,
+    }
+
+    variant view-event {
+        /// A toolbar button.
+        button(string),
+        /// Double click / Enter on a tree or list item.
+        activate(string),
+        select(string),
+        expand(string),
+        collapse(string),
+        /// A form field changed: key and new value (`true`/`false` for checkboxes).
+        field(tuple<string, string>),
+        cell(cell-edit),
+        /// Insert an empty row before this one (the row count: append).
+        insert-row(u32),
+        delete-rows(list<u32>),
+        /// From the `html` body's script.
+        message(string),
+        /// An event added after 1.0, from a body or field added after 1.0.
+        other(extension),
+    }
+}
+
+/// What a plugin's code can ask of its views.
+interface views {
+    use types.{error};
+
+    /// The view (or every custom editor of that id) shows outdated content:
+    /// the IDE renders it again.
+    refresh: func(view: string);
+    /// Sends a message to the script of a view's `html` body.
+    post-message: func(view: string, message: string) -> result<_, error>;
+    /// Opens a terminal tab in the window the call came from, running
+    /// `program` (pinned by a `process:<program>` grant) with `args` in the
+    /// project root: long-running output (logs) and interactive sessions.
+    open-terminal: func(title: string, program: string, args: list<string>) -> result<_, error>;
+    /// Opens `path` (project-relative or absolute, inside the project) in an
+    /// editor of the window the call came from, the caret at `line` and
+    /// `column` (0-based; UTF-16 column): a view's links to code.
+    open-location: func(path: string, line: u32, column: u32) -> result<_, error>;
+}
+
+/// The plugin's own settings (`[contributes.settings]`), as the user set them
+/// (project over global) or the schema's default.
+interface settings {
+    /// The value of `key` as JSON (`true`, `3`, `"text"`), none if unknown.
+    get: func(key: string) -> option<string>;
+}
+
+/// Optional export (world `plugin-views`): content of declared views and
+/// custom editors. For a custom editor, `ctx.editor()` is its document.
+interface view-provider {
+    use view-types.{view, viewport, view-event};
+    use invocation.{invocation};
+    use types.{error};
+
+    render: func(view: string, viewport: option<viewport>, ctx: borrow<invocation>) -> result<view, error>;
+    handle: func(view: string, event: view-event, ctx: borrow<invocation>) -> result<_, error>;
+}
diff --git a/sdk/rust/openidea-plugin/tests/api/released/workspace.wit b/sdk/rust/openidea-plugin/tests/api/released/workspace.wit
new file mode 100644
index 000000000..180040471
--- /dev/null
+++ b/sdk/rust/openidea-plugin/tests/api/released/workspace.wit
@@ -0,0 +1,92 @@
+package openidea:plugin@1.1.0;
+
+interface workspace {
+    use types.{error};
+
+    /// A project open in the IDE.
+    resource project {
+        /// Absolute path of the project root. Requires `project.read`.
+        root: func() -> result<string, error>;
+        /// Reads a UTF-8 text file inside the project (absolute, or relative
+        /// to the root); paths leaving the root are refused. Unsaved editor
+        /// contents win over the disk. Requires `project.read`.
+        read-file: func(path: string) -> result<string, error>;
+        /// Project files whose root-relative path matches `glob` (`**/*Mapper.xml`),
+        /// at most `limit`, as absolute paths. Ignored and excluded files are
+        /// skipped. Requires `project.read`.
+        find-files: func(glob: string, limit: u32) -> result<list<string>, error>;
+    }
+
+    /// Projects open in any window. Requires `project.read`.
+    projects: func() -> result<list<project>, error>;
+}
+
+interface editor {
+    use types.{error, range, text-edit};
+
+    record document {
+        /// Grows with every change; edits name the version they were made for.
+        version: u64,
+        text: string,
+    }
+
+    /// A file open in an editor.
+    resource text-editor {
+        /// Absolute path of the file.
+        path: func() -> string;
+        /// Language id (`rust`, `solidity`, …).
+        language: func() -> string;
+        /// Current version and text. Requires `editor.read`.
+        document: func() -> result<document, error>;
+        /// Selections when the command was invoked (a cursor is an empty
+        /// range). Requires `editor.read`.
+        selections: func() -> result<list<range>, error>;
+        /// Applies `edits` as one undoable change, only if the document is
+        /// still at `version` (else `stale`, and nothing changes). Ranges are
+        /// in that version and must not overlap. Returns the new version.
+        /// Requires `editor.write`.
+        apply-edits: func(version: u64, edits: list<text-edit>) -> result<u64, error>;
+    }
+}
+
+/// Where a command or event comes from.
+interface invocation {
+    use workspace.{project};
+    use editor.{text-editor};
+
+    resource invocation {
+        /// The window's project.
+        project: func() -> option<project>;
+        /// The window's focused editor.
+        editor: func() -> option<text-editor>;
+    }
+}
+
+/// Git, for the repository containing a project.
+interface vcs {
+    use types.{error};
+    use workspace.{project};
+
+    record repository-status {
+        /// Absolute path of the working tree root.
+        root: string,
+        /// `none` when HEAD is detached.
+        branch: option<string>,
+        commit: option<string>,
+        upstream: option<string>,
+        ahead: u32,
+        behind: u32,
+        /// Merge / rebase / cherry-pick in progress.
+        operation: option<string>,
+        /// Files with staged or unstaged changes.
+        changed-files: u32,
+    }
+
+    /// `none` when the project is not in a repository. Requires `vcs.read`.
+    status: func(project: borrow<project>) -> result<option<repository-status>, error>;
+    /// Configured remotes (`name`, fetch `url`), in order. Requires `vcs.read`.
+    remotes: func(project: borrow<project>) -> result<list<tuple<string, string>>, error>;
+    /// Fetches all remotes (pruning deleted branches). Requires `vcs.write`.
+    /// Long-running: call it inside a task.
+    fetch: func(project: borrow<project>) -> result<_, error>;
+}
diff --git a/sdk/rust/openidea-plugin/tests/api_frozen.rs b/sdk/rust/openidea-plugin/tests/api_frozen.rs
index e6723b428..79ca3e07f 100644
--- a/sdk/rust/openidea-plugin/tests/api_frozen.rs
+++ b/sdk/rust/openidea-plugin/tests/api_frozen.rs
@@ -3,11 +3,13 @@
 //! a field added to a record or a case added to a variant breaks every
 //! component built for the release.
 //!
-//! `tests/api/<version>/` is the WIT of each release, copied when it was
-//! frozen. Every interface, type and function in it must still exist in
-//! `wit/` with the same definition; additions are fine. When a version is
-//! released, copy `wit/` to `tests/api/<that version>/`. Until the first
-//! release there is no snapshot and the API may still change freely.
+//! `tests/api/released/` is the WIT of the latest released version. Every
+//! interface, type and function in it must still exist in `wit/` with the same
+//! definition. Additions need a newer version than the snapshot's: under the
+//! released version `wit/` must match it exactly. When a version ships, copy
+//! `wit/` over the snapshot (the release workflow refuses a tag whose `wit/`
+//! version differs from it). Each snapshot passed this check against the one
+//! before, so the latest one covers every earlier release.
 
 use std::collections::BTreeMap;
 use std::path::Path;
@@ -110,71 +112,83 @@ fn anonymous(r: &Resolve, id: TypeId) -> String {
     }
 }
 
-/// The frozen releases (`tests/api/<version>/`), none before the first release.
-fn releases(root: &Path) -> Vec<std::path::PathBuf> {
-    match std::fs::read_dir(root.join("tests/api")) {
-        Ok(dir) => dir.map(|e| e.unwrap().path()).filter(|p| p.is_dir()).collect(),
-        Err(e) if e.kind() == std::io::ErrorKind::NotFound => Vec::new(),
-        Err(e) => panic!("tests/api: {e}"),
-    }
+fn root() -> &'static Path {
+    Path::new(env!("CARGO_MANIFEST_DIR"))
+}
+
+/// The latest released version's WIT.
+fn released() -> std::path::PathBuf {
+    root().join("tests/api/released")
+}
+
+/// The `package openidea:plugin@x.y.z` version of a WIT directory.
+fn version(dir: &Path) -> Vec<u64> {
+    let src = std::fs::read_to_string(dir.join("plugin.wit")).unwrap_or_else(|e| panic!("{}: {e}", dir.display()));
+    let v = src.lines().find_map(|l| l.trim().strip_prefix("package openidea:plugin@")).unwrap();
+    v.trim_end_matches(';').split('.').map(|p| p.parse().unwrap()).collect()
 }
 
 #[test]
 fn the_surface_covers_the_whole_api() {
-    // Keeps the check below meaningful while there is no release to compare.
-    let current = surface(&Path::new(env!("CARGO_MANIFEST_DIR")).join("wit"));
-    assert!(current.len() > 50, "only {} items: did wit/ load?", current.len());
-    assert!(current.keys().any(|k| k.starts_with("world ")));
-    assert!(current.keys().any(|k| k.contains("/func ")));
-    assert!(current.keys().any(|k| k.contains("/type ")));
+    for dir in [root().join("wit"), released()] {
+        let items = surface(&dir);
+        assert!(items.len() > 50, "{}: only {} items: did it load?", dir.display(), items.len());
+        assert!(items.keys().any(|k| k.starts_with("world ")));
+        assert!(items.keys().any(|k| k.contains("/func ")));
+        assert!(items.keys().any(|k| k.contains("/type ")));
+    }
 }
 
 #[test]
-fn released_apis_are_unchanged() {
-    let root = Path::new(env!("CARGO_MANIFEST_DIR"));
-    let current = surface(&root.join("wit"));
-    for dir in releases(root) {
-        let release = surface(&dir);
-        let version = dir.file_name().unwrap().to_string_lossy().into_owned();
-        let mut broken = Vec::new();
-        for (key, was) in &release {
-            match current.get(key) {
-                None => broken.push(format!("{key}: removed (was {was})")),
-                // A world may gain imports and exports; everything else stays as it was.
-                Some(now) if key.starts_with("world ") => {
-                    let had = |s: &str, part: &str| -> Vec<String> {
-                        let start = s.find(part).unwrap() + part.len();
-                        let end = s[start..].find(']').unwrap() + start;
-                        s[start..end].split(", ").filter(|x| !x.is_empty()).map(str::to_owned).collect()
-                    };
-                    for part in ["imports [", "exports ["] {
-                        let now = had(now, part);
-                        for item in had(was, part) {
-                            if !now.contains(&item) {
-                                broken.push(format!("{key}: no longer has {item}"));
-                            }
+fn the_released_api_is_unchanged() {
+    let current = surface(&root().join("wit"));
+    let release = surface(&released());
+    let mut broken = Vec::new();
+    for (key, was) in &release {
+        match current.get(key) {
+            None => broken.push(format!("{key}: removed (was {was})")),
+            // A world may gain imports and exports; everything else stays as it was. Items are
+            // compared without their `@version`: a later minor names them `@1.2.0`, and wasmtime
+            // resolves the release's `@1.1.0` to it.
+            Some(now) if key.starts_with("world ") => {
+                let had = |s: &str, part: &str| -> Vec<String> {
+                    let start = s.find(part).unwrap() + part.len();
+                    let end = s[start..].find(']').unwrap() + start;
+                    s[start..end]
+                        .split(", ")
+                        .filter(|x| !x.is_empty())
+                        .map(|x| x.split('@').next().unwrap_or(x).to_owned())
+                        .collect()
+                };
+                for part in ["imports [", "exports ["] {
+                    let now = had(now, part);
+                    for item in had(was, part) {
+                        if !now.contains(&item) {
+                            broken.push(format!("{key}: no longer has {item}"));
                         }
                     }
                 }
-                Some(now) if now != was => broken.push(format!("{key}:\n      was {was}\n      now {now}")),
-                Some(_) => {}
             }
+            Some(now) if now != was => broken.push(format!("{key}:\n      was {was}\n      now {now}")),
+            Some(_) => {}
         }
-        assert!(broken.is_empty(), "plugin API {version} changed incompatibly:\n  {}", broken.join("\n  "));
-        assert!(release.len() > 50, "{version}: only {} items: did the snapshot load?", release.len());
     }
+    assert!(broken.is_empty(), "the released plugin API changed incompatibly:\n  {}", broken.join("\n  "));
 }
 
 #[test]
-fn the_current_api_is_a_release_or_newer_than_all() {
-    // `wit/` is either a frozen release or the next one; never older.
-    let root = Path::new(env!("CARGO_MANIFEST_DIR"));
-    let src = std::fs::read_to_string(root.join("wit/plugin.wit")).unwrap();
-    let current = src.lines().find_map(|l| l.trim().strip_prefix("package openidea:plugin@")).unwrap();
-    let current: Vec<u64> = current.trim_end_matches(';').split('.').map(|p| p.parse().unwrap()).collect();
-    for dir in releases(root) {
-        let name = dir.file_name().unwrap().to_string_lossy().into_owned();
-        let release: Vec<u64> = name.split('.').map(|p| p.parse().unwrap()).collect();
-        assert!(release <= current, "tests/api/{name} is newer than wit/ ({current:?})");
+fn additions_need_a_newer_version() {
+    // A component built from `wit/` imports what `wit/` declares; under a released version an
+    // IDE of that release would lack the additions and refuse it.
+    let (current, release) = (version(&root().join("wit")), version(&released()));
+    assert!(current >= release, "wit/ ({current:?}) is older than the released API ({release:?})");
+    if current == release {
+        let (now, was) = (surface(&root().join("wit")), surface(&released()));
+        let added: Vec<_> = now.keys().filter(|k| now.get(*k) != was.get(*k)).collect();
+        assert!(
+            added.is_empty(),
+            "wit/ adds to the released version {release:?}; bump the package version in wit/ \
+             (and the SDK's copy, ENGINE_VERSION, API_VERSION) first:\n  {added:?}"
+        );
     }
 }
diff --git a/sdk/rust/openidea-plugin/wit/events.wit b/sdk/rust/openidea-plugin/wit/events.wit
index 2d118d812..7da95eac5 100644
--- a/sdk/rust/openidea-plugin/wit/events.wit
+++ b/sdk/rust/openidea-plugin/wit/events.wit
@@ -1,4 +1,4 @@
-package openidea:plugin@1.0.0;
+package openidea:plugin@1.1.0;
 
 /// Workbench events, delivered in batches to `event-handler.handle`.
 interface events {
diff --git a/sdk/rust/openidea-plugin/wit/exports.wit b/sdk/rust/openidea-plugin/wit/exports.wit
index 065ef9a5f..808377432 100644
--- a/sdk/rust/openidea-plugin/wit/exports.wit
+++ b/sdk/rust/openidea-plugin/wit/exports.wit
@@ -1,4 +1,4 @@
-package openidea:plugin@1.0.0;
+package openidea:plugin@1.1.0;
 
 interface lifecycle {
     use types.{context, error};
diff --git a/sdk/rust/openidea-plugin/wit/host.wit b/sdk/rust/openidea-plugin/wit/host.wit
index b6325cb71..c7ac7f916 100644
--- a/sdk/rust/openidea-plugin/wit/host.wit
+++ b/sdk/rust/openidea-plugin/wit/host.wit
@@ -1,4 +1,4 @@
-package openidea:plugin@1.0.0;
+package openidea:plugin@1.1.0;
 
 /// Writes to the IDE log, tagged with the plugin id.
 interface log {
@@ -8,7 +8,7 @@ interface log {
 }
 
 interface ui {
-    use types.{notification-level};
+    use types.{error, notification-level};
 
     record status-item {
         text: string,
@@ -23,6 +23,10 @@ interface ui {
     /// Shows or updates the plugin's status bar item `id` in every window.
     set-status-item: func(id: string, item: status-item);
     remove-status-item: func(id: string);
+    /// Copies `text` to the system clipboard. Requires `clipboard`.
+    copy-to-clipboard: func(text: string) -> result<_, error>;
+    /// Opens an `http://` or `https://` URL in the user's default browser.
+    open-url: func(url: string) -> result<_, error>;
 }
 
 /// Persistent key-value storage of the plugin (survives restarts and idle
diff --git a/sdk/rust/openidea-plugin/wit/io.wit b/sdk/rust/openidea-plugin/wit/io.wit
index f1fe634a3..b93ea079e 100644
--- a/sdk/rust/openidea-plugin/wit/io.wit
+++ b/sdk/rust/openidea-plugin/wit/io.wit
@@ -1,4 +1,4 @@
-package openidea:plugin@1.0.0;
+package openidea:plugin@1.1.0;
 
 /// Problems in files, shown in the editor and the Problems view.
 interface diagnostics {
diff --git a/sdk/rust/openidea-plugin/wit/plugin.wit b/sdk/rust/openidea-plugin/wit/plugin.wit
index 938ee0842..e9fc0ac85 100644
--- a/sdk/rust/openidea-plugin/wit/plugin.wit
+++ b/sdk/rust/openidea-plugin/wit/plugin.wit
@@ -7,7 +7,7 @@
 /// or processes beyond WASI's clocks and randomness; everything else goes
 /// through the imports below, gated by the capabilities granted in
 /// `plugin.toml` (a missing one returns `error::denied`).
-package openidea:plugin@1.0.0;
+package openidea:plugin@1.1.0;
 
 world plugin {
     import log;
diff --git a/sdk/rust/openidea-plugin/wit/providers.wit b/sdk/rust/openidea-plugin/wit/providers.wit
index 97dd4c7a6..17c1123a8 100644
--- a/sdk/rust/openidea-plugin/wit/providers.wit
+++ b/sdk/rust/openidea-plugin/wit/providers.wit
@@ -1,4 +1,4 @@
-package openidea:plugin@1.0.0;
+package openidea:plugin@1.1.0;
 
 /// Editor features a plugin provides for the languages it declares under
 /// `[[contributes.providers]]` (the host calls only declared kinds). They run
diff --git a/sdk/rust/openidea-plugin/wit/types.wit b/sdk/rust/openidea-plugin/wit/types.wit
index 2e2b48f74..de35cadf6 100644
--- a/sdk/rust/openidea-plugin/wit/types.wit
+++ b/sdk/rust/openidea-plugin/wit/types.wit
@@ -1,4 +1,4 @@
-package openidea:plugin@1.0.0;
+package openidea:plugin@1.1.0;
 
 /// Shared types. Positions are 0-based lines and UTF-16 code unit columns,
 /// as in the editor and LSP.
diff --git a/sdk/rust/openidea-plugin/wit/views.wit b/sdk/rust/openidea-plugin/wit/views.wit
index c4435eced..8a67e222e 100644
--- a/sdk/rust/openidea-plugin/wit/views.wit
+++ b/sdk/rust/openidea-plugin/wit/views.wit
@@ -1,4 +1,4 @@
-package openidea:plugin@1.0.0;
+package openidea:plugin@1.1.0;
 
 /// Declarative views: tool windows declared
 /// under `[[contributes.views]]` and custom editors under
diff --git a/sdk/rust/openidea-plugin/wit/workspace.wit b/sdk/rust/openidea-plugin/wit/workspace.wit
index febca7c6f..180040471 100644
--- a/sdk/rust/openidea-plugin/wit/workspace.wit
+++ b/sdk/rust/openidea-plugin/wit/workspace.wit
@@ -1,4 +1,4 @@
-package openidea:plugin@1.0.0;
+package openidea:plugin@1.1.0;
 
 interface workspace {
     use types.{error};
@@ -84,6 +84,8 @@ interface vcs {
 
     /// `none` when the project is not in a repository. Requires `vcs.read`.
     status: func(project: borrow<project>) -> result<option<repository-status>, error>;
+    /// Configured remotes (`name`, fetch `url`), in order. Requires `vcs.read`.
+    remotes: func(project: borrow<project>) -> result<list<tuple<string, string>>, error>;
     /// Fetches all remotes (pruning deleted branches). Requires `vcs.write`.
     /// Long-running: call it inside a task.
     fetch: func(project: borrow<project>) -> result<_, error>;
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index e99b4838e..0e78c99f0 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -71,8 +71,12 @@ ide-tools = { path = "../crates/ide-tools" }
 ide-plugin = { path = "../crates/ide-plugin" }
 ide-extension = { path = "../crates/ide-extension" }
 ide-docker = { path = "../crates/ide-docker" }
+ide-android = { path = "../crates/ide-android" }
 ide-github = { path = "../crates/ide-github" }
 
+[dev-dependencies]
+tempfile.workspace = true
+
 [target.'cfg(target_os = "macos")'.dependencies]
 block2 = "0.6"
 # Plugin secrets in the login keychain.
@@ -89,6 +93,16 @@ objc2-web-kit = { version = "0.3", default-features = false, features = ["std",
 gtk = "0.18"
 
 [target.'cfg(windows)'.dependencies]
+windows = { version = "0.62", features = [
+    "Win32_Foundation",
+    "Win32_Storage_EnhancedStorage",
+    "Win32_System_Com",
+    "Win32_System_Com_StructuredStorage",
+    "Win32_System_Variant",
+    "Win32_UI_Shell",
+    "Win32_UI_Shell_Common",
+    "Win32_UI_Shell_PropertiesSystem",
+] }
 windows-sys = { version = "0.61", features = [
     "Win32_Foundation",
     "Win32_Graphics_Gdi",
diff --git a/src-tauri/src/commands/android.rs b/src-tauri/src/commands/android.rs
new file mode 100644
index 000000000..3b34b7b52
--- /dev/null
+++ b/src-tauri/src/commands/android.rs
@@ -0,0 +1,40 @@
+//! Logcat tool window: Android devices and their logs (`ide-android`).
+
+use crate::state::AppState;
+use ide_android::{AndroidDevice, LogcatLine};
+use ide_core::{IdeError, IdeResult, RequestId};
+use tauri::State;
+use tauri::ipc::Channel;
+
+async fn blocking<T: Send + 'static>(f: impl FnOnce() -> IdeResult<T> + Send + 'static) -> IdeResult<T> {
+    tauri::async_runtime::spawn_blocking(f).await.map_err(|e| IdeError::internal(e.to_string()))?
+}
+
+/// Devices `adb` knows about, online ones first.
+#[tauri::command]
+#[specta::specta]
+pub async fn android_devices() -> IdeResult<Vec<AndroidDevice>> {
+    blocking(ide_android::devices).await
+}
+
+/// Follows `serial`'s log until the request is cancelled, in batches of lines.
+/// `clear` empties the device's buffers first.
+#[tauri::command]
+#[specta::specta]
+pub async fn android_logcat(
+    state: State<'_, AppState>,
+    request: RequestId,
+    serial: String,
+    clear: bool,
+    on_lines: Channel<Vec<LogcatLine>>,
+) -> IdeResult<()> {
+    let cancel = state.begin_request(request);
+    let result = blocking(move || {
+        ide_android::logcat(&serial, clear, &cancel, &mut |batch| {
+            let _ = on_lines.send(batch);
+        })
+    })
+    .await;
+    state.end_request(request);
+    result
+}
diff --git a/src-tauri/src/commands/app.rs b/src-tauri/src/commands/app.rs
index 8c5e994c5..afed18d58 100644
--- a/src-tauri/src/commands/app.rs
+++ b/src-tauri/src/commands/app.rs
@@ -2,8 +2,8 @@ use crate::state::AppState;
 use ide_core::settings::Settings;
 use ide_core::{EventSink, IdeError, IdeResult, RequestId, TaskId};
 use ide_language::LanguageInfo;
-use ide_workspace::RecentProject;
 use ide_workspace::settings::SettingsScope;
+use ide_workspace::{RecentProject, RecentProjectGroup};
 use serde::{Deserialize, Serialize};
 use specta::Type;
 use std::path::PathBuf;
@@ -46,7 +46,27 @@ pub fn recent_projects(state: State<'_, AppState>) -> Vec<RecentProject> {
 #[tauri::command]
 #[specta::specta]
 pub fn remove_recent_project(state: State<'_, AppState>, path: PathBuf) -> IdeResult<()> {
-    state.recent.remove(&path)
+    state.recent.remove(&path)?;
+    crate::jump_list::refresh(&state.app, state.recent.list());
+    Ok(())
+}
+
+/// The welcome screen's project groups.
+#[tauri::command]
+#[specta::specta]
+pub fn recent_project_groups(state: State<'_, AppState>) -> Vec<RecentProjectGroup> {
+    state.recent.groups()
+}
+
+/// Replaces the project groups; returns them as saved (names trimmed and unique, each
+/// project in one group, only recent projects).
+#[tauri::command]
+#[specta::specta]
+pub fn set_recent_project_groups(
+    state: State<'_, AppState>,
+    groups: Vec<RecentProjectGroup>,
+) -> IdeResult<Vec<RecentProjectGroup>> {
+    state.recent.set_groups(groups)
 }
 
 #[tauri::command]
@@ -107,6 +127,7 @@ pub fn project_rename(window: Window, state: State<'_, AppState>, name: String)
     let value = if name.is_empty() { serde_json::Value::Null } else { serde_json::Value::String(name.to_owned()) };
     project.settings.set(SettingsScope::Project, "general.projectName", value)?;
     state.recent.rename(&project.root, (!name.is_empty()).then_some(name))?;
+    crate::jump_list::refresh(&state.app, state.recent.list());
     Ok(project_info(&project))
 }
 
diff --git a/src-tauri/src/commands/build.rs b/src-tauri/src/commands/build.rs
index c55634b76..fd157cad1 100644
--- a/src-tauri/src/commands/build.rs
+++ b/src-tauri/src/commands/build.rs
@@ -17,11 +17,32 @@ pub async fn build_model(window: Window, state: State<'_, AppState>) -> IdeResul
     ide_host::ops::build::build_model(&state.host, window.label()).await
 }
 
+#[tauri::command]
+#[specta::specta]
+pub async fn gradle_link_projects(
+    window: Window,
+    state: State<'_, AppState>,
+    paths: Vec<String>,
+) -> IdeResult<BuildModel> {
+    ide_host::ops::build::gradle_link_projects(&state.host, window.label(), paths).await
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn gradle_unlink_projects(
+    window: Window,
+    state: State<'_, AppState>,
+    paths: Vec<String>,
+) -> IdeResult<BuildModel> {
+    ide_host::ops::build::gradle_unlink_projects(&state.host, window.label(), paths).await
+}
+
 /// Runs Maven (`help:effective-pom dependency:tree`) or Gradle (`tasks --all`) in the
 /// background, reporting progress on `on_progress`; cancellable with `cancel_request(request)`.
 /// Returns the refreshed model; a failed build is reported in its `syncError`.
 #[tauri::command]
 #[specta::specta]
+#[allow(clippy::too_many_arguments)]
 pub async fn build_sync(
     window: Window,
     state: State<'_, AppState>,
@@ -29,6 +50,7 @@ pub async fn build_sync(
     request: RequestId,
     offline: bool,
     profiles: Vec<String>,
+    build_dir: Option<String>,
     on_progress: Channel<SyncProgress>,
 ) -> IdeResult<BuildModel> {
     ide_host::ops::build::build_sync(
@@ -38,6 +60,7 @@ pub async fn build_sync(
         request,
         offline,
         profiles,
+        build_dir,
         crate::commands::sender(on_progress),
     )
     .await
@@ -53,9 +76,18 @@ pub async fn gradle_dependencies(
     configuration: String,
     offline: bool,
     request: RequestId,
+    build_dir: Option<String>,
 ) -> IdeResult<Vec<ide_build::GradleDependency>> {
-    ide_host::ops::build::gradle_dependencies(&state.host, window.label(), gradle_path, configuration, offline, request)
-        .await
+    ide_host::ops::build::gradle_dependencies(
+        &state.host,
+        window.label(),
+        gradle_path,
+        configuration,
+        offline,
+        request,
+        build_dir,
+    )
+    .await
 }
 
 /// The `.toml` of a version catalog the build imports as `group:artifact:version`, once a
diff --git a/src-tauri/src/commands/db.rs b/src-tauri/src/commands/db.rs
index 0b9781c5b..247716196 100644
--- a/src-tauri/src/commands/db.rs
+++ b/src-tauri/src/commands/db.rs
@@ -250,9 +250,10 @@ pub async fn db_execute(
     request: RequestId,
     id: String,
     statements: Vec<SqlStatement>,
+    skip: u32,
     max_rows: u32,
 ) -> IdeResult<Vec<StatementOutcome>> {
-    ide_host::ops::db::execute(&state.host, window.label(), request, &id, statements, max_rows).await
+    ide_host::ops::db::execute(&state.host, window.label(), request, &id, statements, skip, max_rows).await
 }
 
 #[tauri::command]
diff --git a/src-tauri/src/commands/debug.rs b/src-tauri/src/commands/debug.rs
index e2a23a2f8..522300641 100644
--- a/src-tauri/src/commands/debug.rs
+++ b/src-tauri/src/commands/debug.rs
@@ -98,6 +98,18 @@ pub async fn debug_pause(state: State<'_, AppState>, session: DebugSessionId, th
     ide_host::ops::debug::debug_pause(&state.host, "", session, thread_id).await
 }
 
+#[tauri::command]
+#[specta::specta]
+pub async fn debug_hot_reload(state: State<'_, AppState>, session: DebugSessionId) -> IdeResult<()> {
+    ide_host::ops::debug::debug_hot_reload(&state.host, "", session).await
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn debug_hot_restart(state: State<'_, AppState>, session: DebugSessionId) -> IdeResult<()> {
+    ide_host::ops::debug::debug_hot_restart(&state.host, "", session).await
+}
+
 #[tauri::command]
 #[specta::specta]
 pub async fn debug_step(
diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rs
index 7d8de235f..8a33b8ffd 100644
--- a/src-tauri/src/commands/mod.rs
+++ b/src-tauri/src/commands/mod.rs
@@ -8,6 +8,7 @@
 
 pub mod agent;
 pub mod analysis;
+pub mod android;
 pub mod app;
 pub mod build;
 pub mod bytes;
@@ -48,6 +49,7 @@ pub mod window;
 pub mod window_drag;
 pub mod window_group;
 pub mod workspace;
+pub mod wsl;
 
 use tauri_specta::collect_commands;
 
@@ -63,8 +65,12 @@ pub(crate) fn sender<T: tauri::ipc::IpcResponse + Send + Sync + 'static>(
 pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
     tauri_specta::Builder::<tauri::Wry>::new().commands(collect_commands![
         app::app_info,
+        android::android_devices,
+        android::android_logcat,
         app::recent_projects,
         app::remove_recent_project,
+        app::recent_project_groups,
+        app::set_recent_project_groups,
         app::open_project,
         app::project_trust_status,
         app::project_trust_list,
@@ -256,7 +262,6 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
         vcs::vcs_open_external_log,
         vcs::vcs_log_details,
         vcs::vcs_log_details_batch,
-        vcs::vcs_log_index,
         vcs::vcs_revision_children,
         vcs::vcs_revision_files,
         vcs::vcs_commit_files,
@@ -354,6 +359,8 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
         run::run_tomcat_update,
         run::run_test_reports,
         build::build_model,
+        build::gradle_link_projects,
+        build::gradle_unlink_projects,
         build::build_sync,
         build::gradle_dependencies,
         build::gradle_published_catalog,
@@ -373,6 +380,8 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
         debug::debug_completions,
         debug::debug_resume,
         debug::debug_pause,
+        debug::debug_hot_reload,
+        debug::debug_hot_restart,
         debug::debug_step,
         debug::debug_run_to,
         debug::debug_stop,
@@ -526,6 +535,8 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
         db::db_set_ssh_secret,
         db::db_trust_ssh_host,
         ssh::ssh_test,
+        wsl::wsl_distros,
+        wsl::wsl_resolve,
         ssh::ssh_set_secret,
         ssh::ssh_needs_secret,
         ssh::ssh_trust_host,
diff --git a/src-tauri/src/commands/vcs.rs b/src-tauri/src/commands/vcs.rs
index 934398467..ccb6c016b 100644
--- a/src-tauri/src/commands/vcs.rs
+++ b/src-tauri/src/commands/vcs.rs
@@ -142,16 +142,6 @@ pub async fn vcs_log_details_batch(
 }
 #[tauri::command]
 #[specta::specta]
-pub async fn vcs_log_index(
-    window: Window,
-    state: State<'_, AppState>,
-    repo: Option<PathBuf>,
-    request: Option<RequestId>,
-) -> IdeResult<LogIndexProgress> {
-    ide_host::ops::vcs::vcs_log_index(&state.host, window.label(), repo, request).await
-}
-#[tauri::command]
-#[specta::specta]
 pub async fn vcs_revision_children(
     window: Window,
     state: State<'_, AppState>,
@@ -221,7 +211,7 @@ pub async fn vcs_add_to_ignore(
     state: State<'_, AppState>,
     paths: Vec<PathBuf>,
     destination: IgnoreDestination,
-) -> IdeResult<Vec<String>> {
+) -> IdeResult<Vec<ide_core::IpcPath>> {
     ide_host::ops::vcs::vcs_add_to_ignore(&state.host, window.label(), paths, destination).await
 }
 
diff --git a/src-tauri/src/commands/window.rs b/src-tauri/src/commands/window.rs
index abec5daed..ad0f8c115 100644
--- a/src-tauri/src/commands/window.rs
+++ b/src-tauri/src/commands/window.rs
@@ -52,17 +52,17 @@ pub async fn window_open_file_in_new_window(
     windows::open_file_in_new_window(&app, project, file)
 }
 
-/// [`window_open_project`] for folder `path` on the host of SSH configuration
-/// `ssh_config` (Remote Development); a new window connects itself.
+/// [`window_open_project`] for folder `path` of `target` (an SSH host or a WSL distribution;
+/// Remote Development); a new window connects itself.
 #[tauri::command]
 #[specta::specta]
 pub async fn window_open_remote(
     app: AppHandle,
-    ssh_config: String,
+    target: crate::remote_dev::RemoteTarget,
     path: String,
     new_window: bool,
 ) -> IdeResult<OpenOutcome> {
-    windows::open_remote_window(&app, &ssh_config, &path, new_window)
+    windows::open_remote_window(&app, &target, &path, new_window)
 }
 
 /// Opens an empty (welcome) window; returns its label.
diff --git a/src-tauri/src/commands/wsl.rs b/src-tauri/src/commands/wsl.rs
new file mode 100644
index 000000000..d205337b3
--- /dev/null
+++ b/src-tauri/src/commands/wsl.rs
@@ -0,0 +1,22 @@
+use ide_core::{IdeError, IdeResult};
+use std::time::Duration;
+
+/// Installed WSL distros, for the "Connect to WSL" picker. `wsl.exe` can stall while the WSL
+/// service starts, so the wait is bounded.
+#[tauri::command]
+#[specta::specta]
+pub async fn wsl_distros() -> IdeResult<Vec<String>> {
+    let list = tokio::task::spawn_blocking(ide_core::wsl::list_distros);
+    match tokio::time::timeout(Duration::from_secs(8), list).await {
+        Ok(joined) => joined.map_err(|e| IdeError::internal(e.to_string())),
+        Err(_) => Err(IdeError::internal("wsl.exe did not answer in time")),
+    }
+}
+
+/// The WSL project a `\\wsl.localhost\<distro>\…` folder stands for, so the frontend opens it
+/// through the distro and not as a network folder. `None` for any other path.
+#[tauri::command]
+#[specta::specta]
+pub fn wsl_resolve(path: std::path::PathBuf) -> Option<crate::windows::RemoteLaunch> {
+    crate::windows::wsl_launch(&path)
+}
diff --git a/src-tauri/src/jump_list.rs b/src-tauri/src/jump_list.rs
new file mode 100644
index 000000000..446ba3287
--- /dev/null
+++ b/src-tauri/src/jump_list.rs
@@ -0,0 +1,170 @@
+//! Windows taskbar Jump List: the recent projects of the running window.
+//!
+//! The list is built while OpenIDEA runs, so its taskbar button offers the same
+//! recent projects as Welcome / File › Open Recent. `set_app_id` must run before
+//! the first window is created so the taskbar groups every launch under one
+//! AppUserModelID.
+
+use ide_workspace::RecentProject;
+
+/// Windows shows only a handful of custom destinations; keep the taskbar menu short.
+#[cfg(any(windows, test))]
+const MAX_ITEMS: usize = 10;
+#[cfg(windows)]
+const CATEGORY: &str = "Recent Projects";
+/// Marks a second-instance launch from a Jump List item, so it opens in the existing window.
+pub const OPEN_RECENT_ARG: &str = "--open-recent";
+
+pub fn set_app_id(app_id: &str) {
+    #[cfg(windows)]
+    imp::set_app_id(app_id);
+    #[cfg(not(windows))]
+    let _ = app_id;
+}
+
+/// Rebuilds the taskbar Jump List in the background; `items` is newest first.
+pub fn refresh(app: &tauri::AppHandle, items: Vec<RecentProject>) {
+    #[cfg(windows)]
+    imp::refresh(app, items);
+    #[cfg(not(windows))]
+    let _ = (app, items);
+}
+
+/// The entries a Jump List shows: newest first, capped at [`MAX_ITEMS`].
+#[cfg(any(windows, test))]
+pub(crate) fn visible_items(items: &[RecentProject]) -> Vec<(&str, &std::path::Path)> {
+    items.iter().take(MAX_ITEMS).map(|item| (item.name.as_str(), item.path.0.as_path())).collect()
+}
+
+#[cfg(windows)]
+mod imp {
+    use super::*;
+    use std::sync::Mutex;
+    use windows::Win32::Storage::EnhancedStorage::{PKEY_AppUserModel_ID, PKEY_Title};
+    use windows::Win32::System::Com::StructuredStorage::{PROPVARIANT, PropVariantClear};
+    use windows::Win32::System::Com::{
+        CLSCTX_INPROC_SERVER, COINIT_APARTMENTTHREADED, CoCreateInstance, CoInitializeEx, CoUninitialize,
+    };
+    use windows::Win32::UI::Shell::Common::{IObjectArray, IObjectCollection};
+    use windows::Win32::UI::Shell::PropertiesSystem::IPropertyStore;
+    use windows::Win32::UI::Shell::{
+        DestinationList, EnumerableObjectCollection, ICustomDestinationList, IShellLinkW,
+        SetCurrentProcessExplicitAppUserModelID, ShellLink,
+    };
+    use windows::core::{HSTRING, Interface};
+
+    /// Shell COM is not thread-safe here; serialize updates from simultaneous project opens.
+    static UPDATE_LOCK: Mutex<()> = Mutex::new(());
+
+    pub fn set_app_id(app_id: &str) {
+        if let Err(error) = unsafe { SetCurrentProcessExplicitAppUserModelID(&HSTRING::from(app_id)) } {
+            tracing::warn!(%error, "cannot set the taskbar AppUserModelID");
+        }
+    }
+
+    pub fn refresh(app: &tauri::AppHandle, items: Vec<RecentProject>) {
+        let app_id = app.config().identifier.clone();
+        let worker = std::thread::Builder::new().name("openidea-jump-list".into()).spawn(move || {
+            let _guard = UPDATE_LOCK.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
+            let com = ComGuard::new();
+            if let Err(error) = update(&app_id, &items) {
+                tracing::warn!(%error, "cannot update the taskbar Jump List");
+            }
+            drop(com);
+        });
+        if let Err(error) = worker {
+            tracing::warn!(%error, "cannot start the taskbar Jump List worker");
+        }
+    }
+
+    struct ComGuard {
+        uninitialize: bool,
+    }
+
+    impl ComGuard {
+        fn new() -> Self {
+            let result = unsafe { CoInitializeEx(None, COINIT_APARTMENTTHREADED) };
+            let uninitialize = result.0 >= 0;
+            if !uninitialize {
+                tracing::debug!(%result, "COM already initialized for the taskbar Jump List");
+            }
+            Self { uninitialize }
+        }
+    }
+
+    impl Drop for ComGuard {
+        fn drop(&mut self) {
+            if self.uninitialize {
+                unsafe { CoUninitialize() };
+            }
+        }
+    }
+
+    fn update(app_id: &str, items: &[RecentProject]) -> windows::core::Result<()> {
+        let app_id_hstring = HSTRING::from(app_id);
+        let visible = visible_items(items);
+        unsafe {
+            let list: ICustomDestinationList = CoCreateInstance(&DestinationList, None, CLSCTX_INPROC_SERVER)?;
+            list.SetAppID(&app_id_hstring)?;
+            if visible.is_empty() {
+                let _ = list.DeleteList(&app_id_hstring);
+                return Ok(());
+            }
+            let mut min_slots = 0u32;
+            let _removed: IObjectArray = list.BeginList(&mut min_slots)?;
+            let collection: IObjectCollection =
+                CoCreateInstance(&EnumerableObjectCollection, None, CLSCTX_INPROC_SERVER)?;
+            let exe = HSTRING::from(std::env::current_exe()?.to_string_lossy().as_ref());
+            for (name, path) in visible {
+                let link: IShellLinkW = CoCreateInstance(&ShellLink, None, CLSCTX_INPROC_SERVER)?;
+                link.SetPath(&exe)?;
+                let mut arguments = String::with_capacity(path.as_os_str().len() + OPEN_RECENT_ARG.len() + 3);
+                arguments.push_str(OPEN_RECENT_ARG);
+                arguments.push(' ');
+                arguments.push('"');
+                arguments.push_str(&path.to_string_lossy());
+                arguments.push('"');
+                link.SetArguments(&HSTRING::from(arguments.as_str()))?;
+                link.SetDescription(&HSTRING::from(path.to_string_lossy().as_ref()))?;
+                if let Some(parent) = path.parent() {
+                    link.SetWorkingDirectory(&HSTRING::from(parent.to_string_lossy().as_ref()))?;
+                }
+                link.SetIconLocation(&exe, 0)?;
+                let properties: IPropertyStore = link.cast()?;
+                let mut title = PROPVARIANT::from(name);
+                let mut app_id_value = PROPVARIANT::from(app_id);
+                let title_result = properties.SetValue(&PKEY_Title, &title);
+                let app_id_result = properties.SetValue(&PKEY_AppUserModel_ID, &app_id_value);
+                let _ = PropVariantClear(&mut title);
+                let _ = PropVariantClear(&mut app_id_value);
+                title_result?;
+                app_id_result?;
+                properties.Commit()?;
+                collection.AddObject(&link)?;
+            }
+            let destinations: IObjectArray = collection.cast()?;
+            list.AppendCategory(&HSTRING::from(CATEGORY), &destinations)?;
+            list.CommitList()?;
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ide_core::IpcPath;
+
+    fn item(name: &str, path: &str) -> RecentProject {
+        RecentProject { path: IpcPath::from(path), name: name.into(), opened_at_ms: 0.0, branch: None }
+    }
+
+    #[test]
+    fn shows_the_newest_items_capped() {
+        let items: Vec<_> = (0..15).map(|i| item(&format!("p{i}"), &format!("/p/{i}"))).collect();
+        let visible = visible_items(&items);
+        assert_eq!(visible.len(), 10);
+        assert_eq!(visible[0].0, "p0");
+        assert_eq!(visible[9].0, "p9");
+    }
+}
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 76acd0b65..5f7188edc 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -8,6 +8,7 @@ mod commands;
 #[cfg(debug_assertions)]
 mod dev;
 mod events;
+mod jump_list;
 #[cfg(any(target_os = "linux", test))]
 mod linux_window_state;
 mod logging;
@@ -16,6 +17,7 @@ mod macos;
 mod menu;
 mod plugin_web;
 mod remote_dev;
+mod remote_wsl;
 
 mod state;
 mod theme_frame;
@@ -63,6 +65,8 @@ pub fn run() {
     let context = tauri::generate_context!();
     #[cfg(debug_assertions)]
     let context = dev::configure(context);
+    // Before the first window: one taskbar identity for every launch path.
+    jump_list::set_app_id(&context.config().identifier);
     logging::init(&context.config().identifier);
 
     let refresh_shell_path = ide_host::shell_env::inherit_login_shell_path(&context.config().identifier);
@@ -173,6 +177,7 @@ pub fn run() {
         }
         app.on_menu_event(on_menu_event);
         windows::create_main_window(app.handle())?;
+        jump_list::refresh(app.handle(), app.state::<AppState>().recent.list());
         Ok(())
     })
     .on_window_event(|window, event| match event {
diff --git a/src-tauri/src/macos.rs b/src-tauri/src/macos.rs
index 36cb01413..dcb8bc5f5 100644
--- a/src-tauri/src/macos.rs
+++ b/src-tauri/src/macos.rs
@@ -46,7 +46,9 @@ pub fn new_project_tab_target(app: &AppHandle, launch: &Launch) -> IdeResult<Opt
         let host = app.state::<crate::state::AppState>();
         host.project(w.label()).is_ok_and(|p| !p.light) || host.remote_dev.get(w.label()).is_some()
     });
-    let fullscreen = active.as_ref().is_some_and(|w| w.is_fullscreen().unwrap_or(false));
+    // A project-tab group is fullscreen through simple fullscreen, which the native flag misses.
+    let fullscreen =
+        active.as_ref().is_some_and(|w| w.is_fullscreen().unwrap_or(false) || is_simple_fullscreen(w.label()));
     let light_edit = launch.project.is_none() && launch.remote.is_none();
     Ok(should_group_new_project(tabbing_preference(app)?, fullscreen, active.is_some(), light_edit)
         .then_some(active)
diff --git a/src-tauri/src/remote_dev.rs b/src-tauri/src/remote_dev.rs
index 2d210b4b3..cb025ec88 100644
--- a/src-tauri/src/remote_dev.rs
+++ b/src-tauri/src/remote_dev.rs
@@ -28,24 +28,46 @@ pub async fn remote_bootstrap_list(
     state.remote.list(&ide_ssh::FsConnection::Sftp { ssh }, &path).await
 }
 
+/// Where a remote project lives and how the server there is reached.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
+#[serde(tag = "kind", rename_all = "camelCase")]
+pub enum RemoteTarget {
+    /// The host of SSH configuration `config`.
+    Ssh { config: String },
+    /// A WSL distribution on this machine.
+    Wsl { distro: String },
+}
+
 /// Where the server is installed on the remote host (per version).
 fn install_dir(version: &str) -> String {
-    format!("~/.openidea/server/{version}")
+    format!("~/{SERVER_DIR}/{version}")
 }
 
+/// Under the remote home: where the server builds are kept, one folder per version.
+pub(crate) const SERVER_DIR: &str = ".openidea/server";
+
+/// File name of the server binary on every host.
+pub(crate) const SERVER_BIN: &str = "openidea-server";
+
+/// Printed before a probe's answer: shell start-up files and `wsl.exe` may print first.
+pub(crate) const PROBE_MARK: &str = "__OPENIDEA_PROBE__";
+
 /// One remote window's connection.
 pub struct Connection {
     peer: Peer,
-    pub ssh_config: String,
+    pub target: RemoteTarget,
     pub root: String,
     pub host: String,
+    /// The server's `std::env::consts::OS`: where the project's commands run.
+    pub os: String,
     pub commands: Vec<String>,
     /// Streaming arguments by connection-wide id: the frontend channel and the id
     /// it expects (each webview numbers its own, and a settings window shares this
     /// connection with its parent).
     channels: Channels,
     next_channel: std::sync::atomic::AtomicU64,
-    session: Arc<ide_ssh::Session>,
+    /// Keeps the SSH connection alive; `None` for WSL.
+    session: Option<Arc<ide_ssh::Session>>,
     /// Remote ports forwarded to this machine (Ports tool window), by remote port.
     forwards: Mutex<Vec<(u16, ide_ssh::Tunnel)>>,
 }
@@ -82,13 +104,13 @@ impl Connections {
         self.0.lock().get(window).cloned()
     }
 
-    /// The window connected to folder `root` on the host of SSH configuration `ssh_config`.
-    pub fn window_of(&self, ssh_config: &str, root: &str) -> Option<String> {
+    /// The window connected to folder `root` of `target`.
+    pub fn window_of(&self, target: &RemoteTarget, root: &str) -> Option<String> {
         let root = root.trim_end_matches('/');
         self.0
             .lock()
             .iter()
-            .find(|(_, c)| c.ssh_config == ssh_config && c.root.trim_end_matches('/') == root)
+            .find(|(_, c)| c.target == *target && c.root.trim_end_matches('/') == root)
             .map(|(label, _)| label.clone())
     }
 
@@ -123,7 +145,7 @@ pub struct RemoteProgress {
     pub fraction: Option<f64>,
 }
 
-type Progress = dyn Fn(RemoteStage, Option<f64>) + Send + Sync;
+pub(crate) type Progress = dyn Fn(RemoteStage, Option<f64>) + Send + Sync;
 
 /// A value for one streaming argument of a remote command (`data`: JSON text).
 #[derive(Clone, Serialize, Deserialize, Type)]
@@ -136,9 +158,9 @@ pub struct ChannelFrame {
 #[derive(Serialize, Deserialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct RemoteProject {
-    pub ssh_config: String,
+    pub target: RemoteTarget,
     pub root: String,
-    /// `user@host:port` of the SSH configuration.
+    /// `user@host:port` of the SSH configuration; the distribution name for WSL.
     pub host: String,
     pub server_version: String,
     pub os: String,
@@ -244,7 +266,7 @@ async fn download_server(
 }
 
 /// `uname -sm` → (`linux` | `macos`, `x86_64` | `aarch64`), as Rust names them.
-fn platform(uname: &str) -> (String, String) {
+pub(crate) fn platform(uname: &str) -> (String, String) {
     let mut parts = uname.split_whitespace();
     let os = match parts.next().unwrap_or_default().to_ascii_lowercase().as_str() {
         "darwin" => "macos".to_owned(),
@@ -258,29 +280,30 @@ fn platform(uname: &str) -> (String, String) {
     (os, arch)
 }
 
-/// Makes sure this version of the server is installed on the host; returns its path.
-async fn ensure_server(state: &AppState, session: &ide_ssh::Session, progress: Arc<Progress>) -> IdeResult<String> {
-    progress(RemoteStage::Checking, None);
-    let version = env!("CARGO_PKG_VERSION");
-    let dir = install_dir(version);
-    let q = ide_ssh::shell::tilde_quote;
-    // Between markers: shell start-up files may print to stdout too.
-    const MARK: &str = "__OPENIDEA_PROBE__";
-    let probe = session
-        .exec(&format!("echo {MARK}; uname -sm; ls -d {}/*/openidea-server 2>/dev/null", q(&dir)), None)
-        .await?
-        .stdout_str();
-    let probe = probe.split_once(MARK).map_or(probe.as_str(), |(_, rest)| rest);
-    let mut lines = probe.lines().map(str::trim).filter(|l| !l.is_empty());
-    let (os, arch) = platform(lines.next().unwrap_or_default());
-    let installed: Vec<&str> = lines.collect();
-    let local = match local_server_binary(state, &os, &arch) {
+/// What [`local_server`] settled on.
+pub(crate) enum LocalServer {
+    /// A server binary on this machine and its [`build_id`].
+    Binary(std::path::PathBuf, String),
+    /// No binary available (offline): this build of the version already on the host.
+    Installed(String),
+}
+
+/// The server binary to put on a host of `os`/`arch` whose `installed` builds are known.
+pub(crate) async fn local_server(
+    state: &AppState,
+    version: &str,
+    os: &str,
+    arch: &str,
+    installed: &[String],
+    progress: Arc<Progress>,
+) -> IdeResult<LocalServer> {
+    let local = match local_server_binary(state, os, arch) {
         Some(local) => local,
-        None => match download_server(state, version, &os, &arch, progress.clone()).await {
+        None => match download_server(state, version, os, arch, progress).await {
             Ok(local) => local,
             // Offline: any build of this version already on the host will do.
             Err(e) => {
-                return installed.first().map(|b| b.to_string()).ok_or_else(|| {
+                return installed.first().cloned().map(LocalServer::Installed).ok_or_else(|| {
                     IdeError::unavailable(format!(
                         "no openidea-server {version} for {os}-{arch} ({}). Build it with \
                          `cargo build --release -p ide-host --bin openidea-server` for that platform and put it at {} \
@@ -304,6 +327,27 @@ async fn ensure_server(state: &AppState, session: &ide_ssh::Session, progress: A
     })
     .await
     .map_err(|e| IdeError::internal(e.to_string()))??;
+    Ok(LocalServer::Binary(local, build))
+}
+
+/// Makes sure this version of the server is installed on the host; returns its path.
+async fn ensure_server(state: &AppState, session: &ide_ssh::Session, progress: Arc<Progress>) -> IdeResult<String> {
+    progress(RemoteStage::Checking, None);
+    let version = env!("CARGO_PKG_VERSION");
+    let dir = install_dir(version);
+    let q = ide_ssh::shell::tilde_quote;
+    let probe = session
+        .exec(&format!("echo {PROBE_MARK}; uname -sm; ls -d {}/*/openidea-server 2>/dev/null", q(&dir)), None)
+        .await?
+        .stdout_str();
+    let probe = probe.split_once(PROBE_MARK).map_or(probe.as_str(), |(_, rest)| rest);
+    let mut lines = probe.lines().map(str::trim).filter(|l| !l.is_empty());
+    let (os, arch) = platform(lines.next().unwrap_or_default());
+    let installed: Vec<String> = lines.map(str::to_owned).collect();
+    let (local, build) = match local_server(state, version, &os, &arch, &installed, progress.clone()).await? {
+        LocalServer::Installed(bin) => return Ok(bin),
+        LocalServer::Binary(local, build) => (local, build),
+    };
     if let Some(bin) = installed.iter().find(|b| b.ends_with(&format!("/{build}/openidea-server"))) {
         return Ok(bin.to_string());
     }
@@ -359,14 +403,14 @@ fn build_id(path: &std::path::Path) -> IdeResult<String> {
     Ok(id)
 }
 
-/// File › Remote Development: opens `path` on the host of SSH configuration
-/// `ssh_config` in this window (installs / starts the server as needed).
+/// File › Remote Development: opens `path` on `target` (an SSH host or a WSL distribution)
+/// in this window (installs / starts the server as needed).
 #[tauri::command]
 #[specta::specta]
 pub async fn remote_connect(
     window: Window,
     state: State<'_, AppState>,
-    ssh_config: String,
+    target: RemoteTarget,
     path: String,
     on_progress: Channel<RemoteProgress>,
 ) -> IdeResult<RemoteProject> {
@@ -377,23 +421,39 @@ pub async fn remote_connect(
     let label = AppState::owner_window(window.label()).to_owned();
     state.remote_dev.disconnect(&label);
     state.host.close_project(&label);
-    let config = state.ssh.config(&ssh_config)?;
-    let session = state.ssh.session(&ssh_config).await?;
-    let bin = ensure_server(&state, &session, progress.clone()).await?;
-    progress(RemoteStage::Starting, None);
-    let stream = session
-        .exec_stream(&format!("{} --stdio", ide_ssh::shell::tilde_quote(&bin)))
-        .await
-        .map_err(|e| IdeError::unavailable(format!("cannot start openidea-server: {e}")))?;
-    let (reader, writer) = tokio::io::split(stream);
     let channels: Channels = Arc::default();
     let handler =
         Arc::new(ClientHandler { app: window.app_handle().clone(), window: label.clone(), channels: channels.clone() });
-    let peer = Peer::connect(reader, writer, handler);
+    let tail = crate::remote_wsl::Tail::default();
+    let (peer, session, host, title_tag) = match &target {
+        RemoteTarget::Ssh { config: id } => {
+            let config = state.ssh.config(id)?;
+            let session = state.ssh.session(id).await?;
+            let bin = ensure_server(&state, &session, progress.clone()).await?;
+            progress(RemoteStage::Starting, None);
+            let stream = session
+                .exec_stream(&format!("{} --stdio", ide_ssh::shell::tilde_quote(&bin)))
+                .await
+                .map_err(|e| IdeError::unavailable(format!("cannot start openidea-server: {e}")))?;
+            let (reader, writer) = tokio::io::split(stream);
+            (Peer::connect(reader, writer, handler), Some(session), config.label(), config.label())
+        }
+        RemoteTarget::Wsl { distro } => {
+            let bin = crate::remote_wsl::ensure_server(&state, distro, progress.clone()).await?;
+            progress(RemoteStage::Starting, None);
+            let peer = crate::remote_wsl::spawn(distro, &bin, handler, &tail)?;
+            (peer, None, distro.clone(), format!("WSL: {distro}"))
+        }
+    };
+    // A server that dies on start-up says why on stderr (`wsl.exe` prints its own errors too).
+    let with_output = |e: IdeError| match tail.text() {
+        t if t.is_empty() => e,
+        t => IdeError::unavailable(format!("{}: {t}", e.message)),
+    };
     let info: ServerInfo = peer
         .request("initialize", serde_json::json!({ "version": ide_host::rpc::PROTOCOL_VERSION }), None)
         .await
-        .map_err(ide_host::rpc::error_from_reply)?;
+        .map_err(|e| with_output(ide_host::rpc::error_from_reply(e)))?;
     if info.protocol != ide_host::rpc::PROTOCOL_VERSION {
         return Err(IdeError::unavailable(format!(
             "openidea-server {} speaks protocol {}, this app {}",
@@ -417,12 +477,13 @@ pub async fn remote_connect(
         peer.request("invoke", call, None).await.map_err(ide_host::rpc::error_from_reply)?;
     // As the server resolved it (symlinks, a trailing `/`): the frontend compares it with the project's.
     let root = serde_json::to_value(&project.root).ok().and_then(|v| v.as_str().map(str::to_owned)).unwrap_or(root);
-    let _ = window.set_title(&format!("{} [{}]", project.name, config.label()));
+    let _ = window.set_title(&format!("{} [{title_tag}]", project.name));
     let connection = Arc::new(Connection {
         peer,
-        ssh_config: ssh_config.clone(),
+        target: target.clone(),
         root: root.clone(),
-        host: config.label(),
+        host: host.clone(),
+        os: info.os.clone(),
         commands: commands.clone(),
         channels,
         next_channel: std::sync::atomic::AtomicU64::new(1),
@@ -435,15 +496,7 @@ pub async fn remote_connect(
         sync_plugin_languages(&plugins, &connection, &label).await;
         sync_plugin_packages(&plugins, &connection, &label).await;
     });
-    Ok(RemoteProject {
-        ssh_config,
-        root,
-        host: config.label(),
-        server_version: info.version,
-        os: info.os,
-        commands,
-        project,
-    })
+    Ok(RemoteProject { target, root, host, server_version: info.version, os: info.os, commands, project })
 }
 
 /// Sends the desktop's plugin languages, with the programs granted to them, to
@@ -523,9 +576,11 @@ pub async fn sync_plugin_packages(plugins: &Arc<ide_host::plugins::PluginHost>,
 #[derive(Serialize, Deserialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct RemoteSession {
-    pub ssh_config: String,
+    pub target: RemoteTarget,
     pub root: String,
     pub host: String,
+    /// `linux`, `macos` or `windows`: the OS the project's commands run on.
+    pub os: String,
     pub commands: Vec<String>,
 }
 
@@ -535,9 +590,10 @@ pub struct RemoteSession {
 pub fn remote_current(window: Window, state: State<'_, AppState>) -> Option<RemoteSession> {
     let c = state.remote_dev.get(AppState::owner_window(window.label()))?;
     Some(RemoteSession {
-        ssh_config: c.ssh_config.clone(),
+        target: c.target.clone(),
         root: c.root.clone(),
         host: c.host.clone(),
+        os: c.os.clone(),
         commands: c.commands.clone(),
     })
 }
@@ -584,7 +640,11 @@ pub async fn remote_forward_port(
     if let Some(p) = forwarded(&c).into_iter().find(|p| p.remote_port == remote_port) {
         return Ok(p);
     }
-    let tunnel = ide_ssh::Tunnel::listen_on(c.session.clone(), Some(remote_port), "localhost", remote_port).await?;
+    let session = c
+        .session
+        .clone()
+        .ok_or_else(|| IdeError::unavailable("Forwarding ports is not supported in a WSL project yet"))?;
+    let tunnel = ide_ssh::Tunnel::listen_on(session, Some(remote_port), "localhost", remote_port).await?;
     let port = ForwardedPort { remote_port, local_port: tunnel.port() };
     let mut forwards = c.forwards.lock();
     if let Some(existing) = forwards.iter().find(|(remote, _)| *remote == remote_port) {
@@ -681,10 +741,13 @@ pub async fn remote_import_local(
 ) -> IdeResult<Vec<String>> {
     let label = AppState::owner_window(window.label());
     let c = state.remote_dev.get(label).ok_or_else(|| IdeError::unavailable("Remote project is disconnected"))?;
+    let Some(session) = c.session.clone() else {
+        return Err(IdeError::unavailable("Importing local files is not supported in a WSL project yet"));
+    };
     c.authorize_command(label, "fs_copy").await?;
     let cancel = state.host.begin_request(request);
     let result = async {
-        let fs = ide_ssh::RemoteFs::new(c.session.sftp().await?);
+        let fs = ide_ssh::RemoteFs::new(session.sftp().await?);
         let result = ide_remote::import::import_local(&fs, &from, &to, &cancel).await;
         fs.close().await;
         result
diff --git a/src-tauri/src/remote_wsl.rs b/src-tauri/src/remote_wsl.rs
new file mode 100644
index 000000000..d0ee378c7
--- /dev/null
+++ b/src-tauri/src/remote_wsl.rs
@@ -0,0 +1,282 @@
+//! WSL transport of remote development: `openidea-server --stdio` started with
+//! `wsl.exe --exec` inside a distro, instead of over SSH.
+//!
+//! Every command goes through `--exec`, which runs the program directly without a shell on
+//! the Windows side; only fixed scripts reach `sh -c` inside the distro and everything variable
+//! (paths, versions) is passed as positional arguments, never spliced into the script.
+
+use crate::remote_dev::{PROBE_MARK, Progress, RemoteStage, SERVER_BIN, SERVER_DIR};
+use ide_core::{IdeError, IdeResult};
+use ide_jsonrpc::{Handler, Peer};
+use parking_lot::Mutex;
+use std::collections::VecDeque;
+use std::process::Stdio;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::io::AsyncWriteExt;
+
+/// Bound for the short probes; `wsl.exe` can wait on a distro that is still starting.
+const PROBE_TIMEOUT: Duration = Duration::from_secs(60);
+const INSTALL_TIMEOUT: Duration = Duration::from_secs(300);
+const UPLOAD_CHUNK: usize = 256 * 1024;
+/// Output lines of the server kept for the error shown when it dies early.
+const KEPT_LINES: usize = 20;
+
+/// What the probe learned about a distro.
+#[derive(Debug, PartialEq, Eq)]
+pub(crate) struct Probe {
+    pub home: String,
+    /// `uname -sm`.
+    pub uname: String,
+    /// Installed builds of this version (paths of `openidea-server`).
+    pub installed: Vec<String>,
+}
+
+fn checked(distro: &str) -> IdeResult<&str> {
+    if ide_core::wsl::is_valid_distro(distro) {
+        Ok(distro)
+    } else {
+        Err(IdeError::invalid(format!("'{distro}' is not a valid WSL distribution name")))
+    }
+}
+
+/// `wsl.exe -d <distro> --exec sh -c <script> sh <args>…`.
+fn sh(distro: &str, script: &str, args: &[&str]) -> IdeResult<tokio::process::Command> {
+    let mut cmd = tokio::process::Command::new("wsl.exe");
+    ide_core::process::prepare(cmd.as_std_mut());
+    cmd.args(["-d", checked(distro)?, "--exec", "sh", "-c", script, "sh"])
+        .args(args)
+        .stdin(Stdio::null())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .kill_on_drop(true);
+    Ok(cmd)
+}
+
+/// The reason a `wsl.exe` call failed, as text (its own messages are UTF-16).
+fn failure(distro: &str, out: &std::process::Output) -> IdeError {
+    let mut text = ide_core::wsl::decode_output(&out.stderr);
+    if text.trim().is_empty() {
+        text = ide_core::wsl::decode_output(&out.stdout);
+    }
+    let text: String = text.trim().chars().filter(|c| !c.is_control() || *c == '\n').take(400).collect();
+    IdeError::unavailable(format!("cannot run a command in WSL distribution '{distro}': {text}"))
+}
+
+async fn output(distro: &str, mut cmd: tokio::process::Command, limit: Duration) -> IdeResult<std::process::Output> {
+    let out = tokio::time::timeout(limit, cmd.output())
+        .await
+        .map_err(|_| IdeError::unavailable(format!("WSL distribution '{distro}' did not answer in time")))?
+        .map_err(|e| IdeError::unavailable(format!("cannot start wsl.exe: {e}")))?;
+    if out.status.success() { Ok(out) } else { Err(failure(distro, &out)) }
+}
+
+/// Splits the probe output (after its marker) into [`Probe`].
+fn parse_probe(text: &str) -> IdeResult<Probe> {
+    // Between markers: `wsl.exe` may print notices to stdout before the script runs.
+    let text = text.split_once(PROBE_MARK).map_or("", |(_, rest)| rest);
+    let mut lines = text.lines().map(str::trim).filter(|l| !l.is_empty());
+    let home = lines.next().unwrap_or_default().to_owned();
+    // The path is spliced into nothing, but it must be one clean absolute path.
+    if !home.starts_with('/') || home.chars().any(char::is_control) {
+        return Err(IdeError::unavailable("cannot find the home directory in the WSL distribution"));
+    }
+    let uname = lines.next().unwrap_or_default().to_owned();
+    Ok(Probe { home, uname, installed: lines.map(str::to_owned).collect() })
+}
+
+/// Home directory, platform and installed server builds of `distro` (starts it if stopped).
+pub(crate) async fn probe(distro: &str, version: &str) -> IdeResult<Probe> {
+    let script = format!(
+        r#"echo {PROBE_MARK}; echo "$HOME"; uname -sm; ls -d "$HOME/{SERVER_DIR}/$1"/*/{SERVER_BIN} 2>/dev/null; true"#
+    );
+    let out = output(distro, sh(distro, &script, &[version])?, PROBE_TIMEOUT).await?;
+    parse_probe(&String::from_utf8_lossy(&out.stdout))
+}
+
+/// Where the builds of `version` live in a distro whose home is `home`.
+pub(crate) fn version_dir(home: &str, version: &str) -> String {
+    format!("{}/{SERVER_DIR}/{version}", home.trim_end_matches('/'))
+}
+
+/// Streams `data` into `<version_dir>/<build>/openidea-server` of `distro` and removes the other
+/// builds of the version. Returns the installed path.
+pub(crate) async fn install(
+    distro: &str,
+    version_dir: &str,
+    build: &str,
+    data: &[u8],
+    progress: &Arc<Progress>,
+) -> IdeResult<String> {
+    let build_dir = format!("{version_dir}/{build}");
+    // Per install: another window may be installing the same build right now.
+    let script = format!(
+        r#"set -e; mkdir -p "$1"; p="$1/{SERVER_BIN}.part.$$"; trap 'rm -f "$p"' EXIT; cat > "$p"; chmod 755 "$p"; mv -f "$p" "$1/{SERVER_BIN}"; find "$2" -mindepth 1 -maxdepth 1 ! -name "$3" -exec rm -rf {{}} +"#
+    );
+    let mut cmd = sh(distro, &script, &[&build_dir, version_dir, build])?;
+    cmd.stdin(Stdio::piped());
+    let mut child = cmd.spawn().map_err(|e| IdeError::unavailable(format!("cannot start wsl.exe: {e}")))?;
+    let mut stdin = child.stdin.take().ok_or_else(|| IdeError::internal("wsl.exe stdin unavailable"))?;
+    // `stdin` drops at the end of the upload: that is the EOF `cat` waits for.
+    let upload = async move {
+        for (i, chunk) in data.chunks(UPLOAD_CHUNK).enumerate() {
+            stdin.write_all(chunk).await?;
+            progress(RemoteStage::Uploading, Some(((i + 1) * UPLOAD_CHUNK).min(data.len()) as f64 / data.len() as f64));
+        }
+        stdin.flush().await
+    };
+    let result = tokio::time::timeout(INSTALL_TIMEOUT, async {
+        let uploaded = upload.await;
+        (uploaded, child.wait_with_output().await)
+    })
+    .await
+    .map_err(|_| IdeError::unavailable(format!("installing {SERVER_BIN} in '{distro}' timed out")))?;
+    match result {
+        (Ok(()), Ok(out)) if out.status.success() => Ok(format!("{build_dir}/{SERVER_BIN}")),
+        (_, Ok(out)) => Err(failure(distro, &out)),
+        (_, Err(e)) => Err(IdeError::unavailable(format!("installing {SERVER_BIN} failed: {e}"))),
+    }
+}
+
+/// The last lines the server (or `wsl.exe`) wrote outside the protocol.
+#[derive(Clone, Default)]
+pub(crate) struct Tail(Arc<Mutex<VecDeque<String>>>);
+
+impl Tail {
+    fn push(&self, line: String) {
+        let mut lines = self.0.lock();
+        if lines.len() == KEPT_LINES {
+            lines.pop_front();
+        }
+        lines.push_back(line);
+    }
+
+    pub fn text(&self) -> String {
+        self.0.lock().iter().cloned().collect::<Vec<_>>().join("\n")
+    }
+}
+
+/// Starts `bin --stdio` in `distro` and speaks the protocol over its stdio. The process dies
+/// with the connection.
+pub(crate) fn spawn(distro: &str, bin: &str, handler: Arc<dyn Handler>, tail: &Tail) -> IdeResult<Peer> {
+    spawn_with(ide_core::wsl::EXE, distro, bin, handler, tail)
+}
+
+/// [`spawn`] through `launcher` instead of `wsl.exe` (tests put a stand-in there).
+fn spawn_with(launcher: &str, distro: &str, bin: &str, handler: Arc<dyn Handler>, tail: &Tail) -> IdeResult<Peer> {
+    let args: Vec<String> = ["-d", checked(distro)?, "--exec", bin, "--stdio"].map(str::to_owned).into();
+    let tail = tail.clone();
+    Peer::spawn(launcher, &args, &std::env::temp_dir(), &[], handler, Box::new(move |line| tail.push(line)))
+        .map_err(|e| IdeError::unavailable(format!("cannot start wsl.exe: {e}")))
+}
+
+/// Makes sure this version of the server is installed in `distro`; returns its path there.
+pub(crate) async fn ensure_server(
+    state: &crate::state::AppState,
+    distro: &str,
+    progress: Arc<Progress>,
+) -> IdeResult<String> {
+    use crate::remote_dev::{LocalServer, local_server, platform};
+    progress(RemoteStage::Checking, None);
+    let version = env!("CARGO_PKG_VERSION");
+    let probe = probe(distro, version).await?;
+    let (os, arch) = platform(&probe.uname);
+    if os != "linux" {
+        return Err(IdeError::unavailable(format!("'{distro}' reports {os} instead of linux")));
+    }
+    let (local, build) = match local_server(state, version, &os, &arch, &probe.installed, progress.clone()).await? {
+        LocalServer::Installed(bin) => return Ok(bin),
+        LocalServer::Binary(local, build) => (local, build),
+    };
+    if let Some(bin) = probe.installed.iter().find(|b| b.ends_with(&format!("/{build}/{SERVER_BIN}"))) {
+        return Ok(bin.clone());
+    }
+    let started = std::time::Instant::now();
+    progress(RemoteStage::Uploading, Some(0.0));
+    let data = tokio::fs::read(&local).await?;
+    let bin = install(distro, &version_dir(&probe.home, version), &build, &data, &progress).await?;
+    tracing::info!("installed {SERVER_BIN} in WSL '{distro}' in {:?}", started.elapsed());
+    Ok(bin)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const HOME: &str = "/home/me";
+    const UNAME: &str = "Linux x86_64";
+
+    #[test]
+    fn probe_output_is_read_after_the_marker() {
+        let installed = format!("{}/ab/{SERVER_BIN}", version_dir(HOME, "1"));
+        let text = format!("wsl: notice\n{PROBE_MARK}\n{HOME}\n{UNAME}\n{installed}\n");
+        let p = parse_probe(&text).unwrap();
+        assert_eq!(p, Probe { home: HOME.into(), uname: UNAME.into(), installed: vec![installed] });
+    }
+
+    #[test]
+    fn a_probe_without_a_clean_home_is_refused() {
+        assert!(parse_probe(&format!("{HOME}\n{UNAME}\n")).is_err(), "no marker");
+        assert!(parse_probe(&format!("{PROBE_MARK}\nrelative\n{UNAME}\n")).is_err());
+        assert!(parse_probe(&format!("{PROBE_MARK}\n")).is_err());
+    }
+
+    #[test]
+    fn invalid_distro_names_never_reach_wsl_exe() {
+        for bad in ["", "--exec", "a b", "a;b"] {
+            assert!(sh(bad, "true", &[]).is_err(), "{bad}");
+        }
+        assert!(sh("Ubuntu-24.04", "true", &[]).is_ok());
+    }
+
+    #[test]
+    fn version_dir_ignores_a_trailing_slash() {
+        assert_eq!(version_dir(&format!("{HOME}/"), "1.2.3"), format!("{HOME}/{SERVER_DIR}/1.2.3"));
+    }
+
+    struct Silent;
+    impl Handler for Silent {
+        fn on_notification(&self, _: &str, _: serde_json::Value) {}
+        fn on_request(&self, method: &str, _: serde_json::Value) -> Result<serde_json::Value, (i64, String)> {
+            Err((ide_jsonrpc::codes::METHOD_NOT_FOUND, method.to_owned()))
+        }
+    }
+
+    /// A stand-in for `wsl.exe` that checks the arguments it is given, prints a UTF-16 notice
+    /// the way the real one does, then answers one request.
+    #[cfg(unix)]
+    #[tokio::test]
+    async fn speaks_the_protocol_through_the_launcher_after_its_utf16_notice() {
+        use std::os::unix::fs::PermissionsExt;
+        let (distro, bin) = ("Debian-12", "/home/me/server");
+        let dir = tempfile::tempdir().unwrap();
+        let launcher = dir.path().join("fake-wsl");
+        let script = format!(
+            r#"#!/bin/sh
+[ "$*" = "-d {distro} --exec {bin} --stdio" ] || {{ echo "unexpected arguments: $*" >&2; exit 2; }}
+printf '\377\376N\000o\000\r\000\n\000'
+while read -r line; do
+  line=${{line%?}}
+  case "$line" in Content-Length:*) len=${{line#*: }} ;; "") break ;; esac
+done
+head -c "$len" >/dev/null
+body='{{"jsonrpc":"2.0","id":1,"result":"pong"}}'
+printf 'Content-Length: %s\r\n\r\n%s' "${{#body}}" "$body"
+"#
+        );
+        std::fs::write(&launcher, script).unwrap();
+        std::fs::set_permissions(&launcher, std::fs::Permissions::from_mode(0o755)).unwrap();
+        let tail = Tail::default();
+        let peer = spawn_with(launcher.to_str().unwrap(), distro, bin, Arc::new(Silent), &tail).unwrap();
+        let reply: String = peer.request("ping", serde_json::Value::Null, None).await.unwrap_or_else(|e| {
+            panic!("{e:?}; launcher said: {}", tail.text());
+        });
+        assert_eq!(reply, "pong");
+    }
+
+    #[tokio::test]
+    async fn a_bad_distro_name_never_starts_the_launcher() {
+        let err = spawn_with("does-not-exist", "-d", "/x", Arc::new(Silent), &Tail::default()).err().unwrap();
+        assert!(err.message.contains("not a valid"), "{}", err.message);
+    }
+}
diff --git a/src-tauri/src/state.rs b/src-tauri/src/state.rs
index f651c71f9..f0882dbcb 100644
--- a/src-tauri/src/state.rs
+++ b/src-tauri/src/state.rs
@@ -145,6 +145,7 @@ impl AppState {
         if !display_name.trim().is_empty() {
             self.recent.rename(&project.root, Some(display_name.trim()))?;
         }
+        crate::jump_list::refresh(&self.app, self.recent.list());
         Ok(project)
     }
 
diff --git a/src-tauri/src/windows.rs b/src-tauri/src/windows.rs
index a0db3c123..2bcaa63bd 100644
--- a/src-tauri/src/windows.rs
+++ b/src-tauri/src/windows.rs
@@ -10,6 +10,7 @@
 //! [`AppState::project`]). Their labels name the kind and the parent
 //! (`settings-main`, `comparison-project-2-3`); their [`Launch`] says what to show.
 
+use crate::remote_dev::RemoteTarget;
 use crate::state::AppState;
 use crate::theme_frame::builtin_frame;
 use ide_core::settings::AppearanceSettings;
@@ -101,14 +102,20 @@ pub struct FilePosition {
     pub column: u32,
 }
 
-/// A project folder on the host of an SSH configuration.
+/// A project folder on an SSH host or in a WSL distribution.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct RemoteLaunch {
-    pub ssh_config: String,
+    pub target: RemoteTarget,
     pub path: String,
 }
 
+/// The remote launch for a folder of the `\\wsl.localhost\<distro>` share, if it is one.
+pub fn wsl_launch(path: &Path) -> Option<RemoteLaunch> {
+    let w = ide_core::wsl::parse(path)?;
+    Some(RemoteLaunch { target: RemoteTarget::Wsl { distro: w.distro }, path: w.path })
+}
+
 #[derive(Default)]
 pub struct WindowsState {
     pub groups: Mutex<ide_workspace::window_groups::WindowGroups>,
@@ -647,6 +654,10 @@ pub fn open_project_window(
     new_window: bool,
     files: Vec<PathBuf>,
 ) -> IdeResult<OpenOutcome> {
+    // Before touching the share: a stat on `\\wsl.localhost` is what makes it slow.
+    if let Some(remote) = wsl_launch(path) {
+        return open_remote_window(app, &remote.target, &remote.path, new_window);
+    }
     let root = dunce::canonicalize(path).map_err(|e| IdeError::not_found(format!("{}: {e}", path.display())))?;
     tracing::info!("open_project_window {} new_window={new_window}", root.display());
     if let Some(w) = find_project_window(app, &root) {
@@ -683,12 +694,16 @@ pub fn open_files_window(app: &AppHandle, caller: &str, files: Vec<PathBuf>) ->
     here.into_iter().map(Into::into).collect()
 }
 
-/// [`open_project_window`] for folder `path` on the host of SSH configuration
-/// `ssh_config` (Remote Development).
-pub fn open_remote_window(app: &AppHandle, ssh_config: &str, path: &str, new_window: bool) -> IdeResult<OpenOutcome> {
-    tracing::info!("open_remote_window {ssh_config}:{path} new_window={new_window}");
+/// [`open_project_window`] for folder `path` of `target` (Remote Development).
+pub fn open_remote_window(
+    app: &AppHandle,
+    target: &RemoteTarget,
+    path: &str,
+    new_window: bool,
+) -> IdeResult<OpenOutcome> {
+    tracing::info!("open_remote_window {target:?}:{path} new_window={new_window}");
     let windows = app.webview_windows();
-    let open = app.try_state::<AppState>().and_then(|s| s.remote_dev.window_of(ssh_config, path));
+    let open = app.try_state::<AppState>().and_then(|s| s.remote_dev.window_of(target, path));
     if let Some(w) = open.and_then(|label| windows.get(&label)) {
         focus(w);
         return Ok(OpenOutcome::Focused { label: w.label().to_owned() });
@@ -697,7 +712,7 @@ pub fn open_remote_window(app: &AppHandle, ssh_config: &str, path: &str, new_win
         return Ok(OpenOutcome::Current);
     }
     let title = path.trim_end_matches('/').rsplit('/').next().filter(|n| !n.is_empty() && *n != "~").map(str::to_owned);
-    let remote = RemoteLaunch { ssh_config: ssh_config.to_owned(), path: path.to_owned() };
+    let remote = RemoteLaunch { target: target.clone(), path: path.to_owned() };
     let window = create_window_for(app, title, Launch { remote: Some(remote), ..Default::default() }, false)?;
     Ok(OpenOutcome::Opened { label: window.label().to_owned() })
 }
@@ -709,18 +724,41 @@ pub enum Holds {
     Nothing,
     LightEdit,
     Project(PathBuf),
-    /// A remote project.
+    /// A project inside a WSL distribution (`path` is the Linux path).
+    Wsl {
+        distro: String,
+        path: String,
+    },
+    /// An SSH remote project.
     Other,
 }
 
+impl Holds {
+    fn of_remote(remote: &RemoteLaunch) -> Self {
+        match &remote.target {
+            RemoteTarget::Wsl { distro } => Holds::Wsl { distro: distro.clone(), path: remote.path.clone() },
+            RemoteTarget::Ssh { .. } => Holds::Other,
+        }
+    }
+
+    fn is_wsl_folder(&self, remote: &RemoteLaunch) -> bool {
+        match (self, &remote.target) {
+            (Holds::Wsl { distro, path }, RemoteTarget::Wsl { distro: d }) => {
+                distro.eq_ignore_ascii_case(d) && path.trim_end_matches('/') == remote.path.trim_end_matches('/')
+            }
+            _ => false,
+        }
+    }
+}
+
 /// What window `label` holds: its open project, else what its pending launch is about to open.
 fn holds(app: &AppHandle, label: &str) -> Holds {
     let state = app.try_state::<AppState>();
     if let Some(project) = state.as_ref().and_then(|s| s.project(label).ok()) {
         return if project.light { Holds::LightEdit } else { Holds::Project(project.root.clone()) };
     }
-    if state.is_some_and(|s| s.remote_dev.get(label).is_some()) {
-        return Holds::Other;
+    if let Some(c) = state.as_ref().and_then(|s| s.remote_dev.get(label)) {
+        return Holds::of_remote(&RemoteLaunch { target: c.target.clone(), path: c.root.clone() });
     }
     pending_holds(app.state::<WindowsState>().pending(label).as_ref())
 }
@@ -728,7 +766,7 @@ fn holds(app: &AppHandle, label: &str) -> Holds {
 fn pending_holds(launch: Option<&Launch>) -> Holds {
     match launch {
         Some(Launch { project: Some(root), .. }) => Holds::Project(root.to_path_buf()),
-        Some(Launch { remote: Some(_), .. }) => Holds::Other,
+        Some(Launch { remote: Some(remote), .. }) => Holds::of_remote(remote),
         Some(l) if !l.files.is_empty() => Holds::LightEdit,
         _ => Holds::Nothing,
     }
@@ -745,6 +783,8 @@ pub enum OpenStep {
     Launch(String, Launch),
     /// A new window opens the project folder or (without one) the files in LightEdit.
     New(Option<PathBuf>, Vec<PathBuf>),
+    /// A new window connects to a WSL distribution.
+    NewRemote(RemoteLaunch),
 }
 
 /// Where a file inside a project goes: a window with it open, or the step opening it.
@@ -776,6 +816,17 @@ pub fn plan_open(paths: Vec<(PathBuf, bool)>, windows: &[(String, Holds)]) -> Ve
         })
         .collect();
     for dir in dirs {
+        // A folder of a WSL distro opens as a WSL project, not as a network folder.
+        if let Some(remote) = wsl_launch(&dir) {
+            steps.push(match windows.iter().find(|(_, h)| h.is_wsl_folder(&remote)) {
+                Some((label, _)) => OpenStep::Focus(label.clone()),
+                None => match free.next() {
+                    Some(label) => OpenStep::Launch(label, Launch { remote: Some(remote), ..Default::default() }),
+                    None => OpenStep::NewRemote(remote),
+                },
+            });
+            continue;
+        }
         if let Some((label, _)) = windows.iter().find(|(_, h)| matches!(h, Holds::Project(root) if *root == dir)) {
             steps.push(OpenStep::Focus(label.clone()));
             continue;
@@ -799,7 +850,9 @@ pub fn plan_open(paths: Vec<(PathBuf, bool)>, windows: &[(String, Holds)]) -> Ve
             Some(ProjectTarget::Step(i)) => match &mut steps[*i] {
                 OpenStep::Launch(_, launch) => launch.files.push(file.into()),
                 OpenStep::New(_, list) => list.push(file),
-                OpenStep::Focus(_) | OpenStep::Files(..) => unreachable!("folders opened by the plan launch or open"),
+                OpenStep::Focus(_) | OpenStep::Files(..) | OpenStep::NewRemote(_) => {
+                    unreachable!("folders opened by the plan launch or open")
+                }
             },
             None => loose.push(file),
         }
@@ -870,8 +923,17 @@ pub fn open_path(app: &AppHandle, path: &Path) {
 /// Opens paths from outside the app (a second instance, Finder's Open With, the Dock):
 /// see [`plan_open`]; the focused window is the preferred free one.
 pub fn open_paths(app: &AppHandle, paths: Vec<PathBuf>) {
+    let (existing, missing): (Vec<_>, Vec<_>) = paths.into_iter().partition(|path| path.exists());
+    if !missing.is_empty() {
+        let paths = missing.iter().map(|path| path.display().to_string()).collect::<Vec<_>>().join("\n");
+        app.state::<AppState>().sink.emit(ide_core::IdeEvent::Notify {
+            level: ide_core::event::NotifyLevel::Warning,
+            title: "Cannot open path".into(),
+            body: Some(format!("The path does not exist:\n{paths}")),
+        });
+    }
     let preferred = target_window(app).map(|w| w.label().to_owned());
-    run_open(app, plan_open(resolve(paths), &window_holds(app, preferred.as_deref())));
+    run_open(app, plan_open(resolve(existing), &window_holds(app, preferred.as_deref())));
 }
 
 /// What each window holds, `preferred` first.
@@ -911,6 +973,17 @@ fn run_open(app: &AppHandle, steps: Vec<OpenStep>) {
                 }
             }
             OpenStep::New(project, files) => spawn_window_with(app, project, files),
+            OpenStep::NewRemote(remote) => {
+                let app = app.clone();
+                // Off the event-loop thread, like `spawn_window`.
+                tauri::async_runtime::spawn(async move {
+                    let title = remote.path.trim_end_matches('/').rsplit('/').next().map(str::to_owned);
+                    let launch = Launch { remote: Some(remote), ..Default::default() };
+                    if let Err(e) = create_window_for(&app, title, launch, false) {
+                        tracing::warn!("cannot open window: {}", e.message);
+                    }
+                });
+            }
         }
     }
 }
@@ -923,15 +996,43 @@ pub fn opened_paths(urls: &[tauri::Url]) -> Vec<PathBuf> {
 
 /// What a window opens for a command-line path: a folder as its project, a file in LightEdit.
 pub fn path_launch(path: PathBuf) -> Launch {
-    if path.is_dir() {
-        Launch { project: Some(path.into()), ..Default::default() }
-    } else {
+    let is_dir = path.is_dir();
+    launch_for(path, is_dir)
+}
+
+/// [`path_launch`] once the path is known to be a folder or not: only a WSL *folder* is a
+/// remote project, a file of the share stays a LightEdit file.
+fn launch_for(path: PathBuf, is_dir: bool) -> Launch {
+    if !is_dir {
         Launch { files: vec![path.into()], ..Default::default() }
+    } else if let Some(remote) = wsl_launch(&path) {
+        Launch { remote: Some(remote), ..Default::default() }
+    } else {
+        Launch { project: Some(path.into()), ..Default::default() }
     }
 }
 
 /// Second instance launched: focus this one and open its path argument.
 pub fn on_second_instance(app: &AppHandle, args: Vec<String>, cwd: String) {
+    if args.iter().any(|arg| arg == crate::jump_list::OPEN_RECENT_ARG)
+        && let Some(path) = cli_path(&args, Path::new(&cwd)).filter(|path| path.exists())
+    {
+        let target = target_window(app)
+            .filter(|window| auxiliary_parent(window.label()).is_none())
+            .or_else(|| project_window_labels(app).into_iter().find_map(|label| app.get_webview_window(&label)));
+        if let Some(window) = target {
+            let _ = app.emit_to(
+                window.label(),
+                crate::menu::MENU_EVENT,
+                crate::menu::MenuRoute {
+                    action: crate::menu::OPEN_RECENT_ACTION.into(),
+                    arg: Some(ide_core::ipc_path::to_ipc(&path)),
+                },
+            );
+            focus(&window);
+            return;
+        }
+    }
     match cli_path(&args, Path::new(&cwd)) {
         Some(path) => {
             remember_cli_position(&app.state::<WindowsState>(), &args, &path);
@@ -1382,6 +1483,17 @@ mod tests {
         assert_eq!((launch.project, launch.files), (None, vec![file.into()]));
     }
 
+    #[test]
+    fn first_launch_keeps_wsl_files_apart_from_wsl_folders() {
+        let share = PathBuf::from(r"\\wsl.localhost\Ubuntu\home\me\app");
+        let folder = launch_for(share.clone(), true);
+        let remote =
+            RemoteLaunch { target: RemoteTarget::Wsl { distro: "Ubuntu".into() }, path: "/home/me/app".into() };
+        assert_eq!((folder.remote, folder.project, folder.files.len()), (Some(remote), None, 0));
+        let file = launch_for(share.join("main.py"), false);
+        assert_eq!((file.remote, file.project, file.files.len()), (None, None, 1));
+    }
+
     fn p(s: &str) -> PathBuf {
         PathBuf::from(s)
     }
@@ -1478,6 +1590,33 @@ mod tests {
         );
     }
 
+    #[test]
+    fn wsl_folders_open_as_wsl_projects() {
+        let (distro, linux_path) = ("Debian-12", "/srv/app");
+        let share = format!(r"\\wsl.localhost\{distro}{}", linux_path.replace('/', r"\"));
+        let share = share.as_str();
+        let remote = wsl_launch(&p(share)).unwrap();
+        assert_eq!(
+            remote,
+            RemoteLaunch { target: RemoteTarget::Wsl { distro: distro.into() }, path: linux_path.into() }
+        );
+        assert!(wsl_launch(&p(linux_path)).is_none());
+        let launch = Launch { remote: Some(remote.clone()), ..Default::default() };
+        let folder = vec![(p(share), true)];
+        // A free window connects, else a new one; the window that has it open is focused.
+        assert_eq!(plan_open(folder.clone(), &[w("main", Holds::Nothing)]), [OpenStep::Launch("main".into(), launch)]);
+        assert_eq!(plan_open(folder.clone(), &[w("main", Holds::LightEdit)]), [OpenStep::NewRemote(remote.clone())]);
+        let open = Holds::Wsl { distro: distro.to_lowercase(), path: format!("{linux_path}/") };
+        assert_eq!(
+            plan_open(folder, &[w("main", Holds::Nothing), w("project-1", open)]),
+            [OpenStep::Focus("project-1".into())]
+        );
+        // Another distro's folder is a different project.
+        let other = Holds::Wsl { distro: format!("{distro}-other"), path: linux_path.into() };
+        assert!(!other.is_wsl_folder(&remote));
+        assert_eq!(launch_for(p(share), true).remote, Some(remote));
+    }
+
     #[test]
     fn files_opened_from_a_window_go_to_their_project_window_else_light_edit() {
         let windows = [
diff --git a/src-tauri/tauri.conf.json b/src-tauri/tauri.conf.json
index b85225109..e20d316de 100644
--- a/src-tauri/tauri.conf.json
+++ b/src-tauri/tauri.conf.json
@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "OpenIDEA",
-  "version": "0.1.36",
+  "version": "0.1.37",
   "identifier": "ai.l0ng.openidea",
   "build": {
     "beforeDevCommand": "pnpm dev",
diff --git a/src/bindings.ts b/src/bindings.ts
index d46c6bb64..39dfd5848 100644
--- a/src/bindings.ts
+++ b/src/bindings.ts
@@ -8,8 +8,22 @@ import { invoke as __TAURI_INVOKE, Channel } from "@tauri-apps/api/core";
 /** Commands */
 export const commands = {
 	appInfo: () => __TAURI_INVOKE<AppInfo>("app_info"),
+	/**  Devices `adb` knows about, online ones first. */
+	androidDevices: () => typedError<AndroidDevice[], IdeError>(__TAURI_INVOKE("android_devices")),
+	/**
+	 *  Follows `serial`'s log until the request is cancelled, in batches of lines.
+	 *  `clear` empties the device's buffers first.
+	 */
+	androidLogcat: (request: RequestId, serial: string, clear: boolean, onLines: Channel<LogcatLine[]>) => typedError<null, IdeError>(__TAURI_INVOKE("android_logcat", { request, serial, clear, onLines })),
 	recentProjects: () => __TAURI_INVOKE<RecentProject[]>("recent_projects"),
 	removeRecentProject: (path: string) => typedError<null, IdeError>(__TAURI_INVOKE("remove_recent_project", { path })),
+	/**  The welcome screen's project groups. */
+	recentProjectGroups: () => __TAURI_INVOKE<RecentProjectGroup[]>("recent_project_groups"),
+	/**
+	 *  Replaces the project groups; returns them as saved (names trimmed and unique, each
+	 *  project in one group, only recent projects).
+	 */
+	setRecentProjectGroups: (groups: RecentProjectGroup[]) => typedError<RecentProjectGroup[], IdeError>(__TAURI_INVOKE("set_recent_project_groups", { groups })),
 	openProject: (path: string) => typedError<ProjectInfo_Serialize, IdeError>(__TAURI_INVOKE("open_project", { path })),
 	projectTrustStatus: (path: string) => typedError<TrustStatus, IdeError>(__TAURI_INVOKE("project_trust_status", { path })),
 	projectTrustList: () => typedError<TrustDecisions, IdeError>(__TAURI_INVOKE("project_trust_list")),
@@ -482,7 +496,6 @@ export const commands = {
 	vcsOpenExternalLog: (path: string) => typedError<IpcPath, IdeError>(__TAURI_INVOKE("vcs_open_external_log", { path })),
 	vcsLogDetails: (repo: string | null, revision: string) => typedError<LogDetails, IdeError>(__TAURI_INVOKE("vcs_log_details", { repo, revision })),
 	vcsLogDetailsBatch: (repo: string | null, revisions: string[], request: RequestId) => typedError<LogDetails[], IdeError>(__TAURI_INVOKE("vcs_log_details_batch", { repo, revisions, request })),
-	vcsLogIndex: (repo: string | null, request: number | null) => typedError<LogIndexProgress, IdeError>(__TAURI_INVOKE("vcs_log_index", { repo, request })),
 	vcsRevisionChildren: (repo: string | null, revision: string, directory: string) => typedError<string[], IdeError>(__TAURI_INVOKE("vcs_revision_children", { repo, revision, directory })),
 	vcsRevisionFiles: (repo: string | null, revision: string) => typedError<string[], IdeError>(__TAURI_INVOKE("vcs_revision_files", { repo, revision })),
 	vcsCommitFiles: (repo: string | null, commit: string) => typedError<ChangedFile[], IdeError>(__TAURI_INVOKE("vcs_commit_files", { repo, commit })),
@@ -491,7 +504,7 @@ export const commands = {
 	vcsBranches: (repo: string | null) => typedError<Branch[], IdeError>(__TAURI_INVOKE("vcs_branches", { repo })),
 	vcsStashes: (repo: string | null) => typedError<Stash[], IdeError>(__TAURI_INVOKE("vcs_stashes", { repo })),
 	vcsStage: (paths: string[]) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_stage", { paths })),
-	vcsAddToIgnore: (paths: string[], destination: IgnoreDestination) => typedError<string[], IdeError>(__TAURI_INVOKE("vcs_add_to_ignore", { paths, destination })),
+	vcsAddToIgnore: (paths: string[], destination: IgnoreDestination) => typedError<IpcPath[], IdeError>(__TAURI_INVOKE("vcs_add_to_ignore", { paths, destination })),
 	vcsUnstage: (paths: string[]) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_unstage", { paths })),
 	vcsStagePatch: (patch: string) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_stage_patch", { patch })),
 	vcsDiscard: (paths: string[]) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_discard", { paths })),
@@ -664,14 +677,16 @@ export const commands = {
 	runTestReports: (module: string | null, sinceMs: number | null) => typedError<TestCaseReport[], IdeError>(__TAURI_INVOKE("run_test_reports", { module, sinceMs })),
 	/**  Maven and Gradle projects of the window's project, from the build files plus the last sync. */
 	buildModel: () => typedError<BuildModel, IdeError>(__TAURI_INVOKE("build_model")),
+	gradleLinkProjects: (paths: string[]) => typedError<BuildModel, IdeError>(__TAURI_INVOKE("gradle_link_projects", { paths })),
+	gradleUnlinkProjects: (paths: string[]) => typedError<BuildModel, IdeError>(__TAURI_INVOKE("gradle_unlink_projects", { paths })),
 	/**
 	 *  Runs Maven (`help:effective-pom dependency:tree`) or Gradle (`tasks --all`) in the
 	 *  background, reporting progress on `on_progress`; cancellable with `cancel_request(request)`.
 	 *  Returns the refreshed model; a failed build is reported in its `syncError`.
 	 */
-	buildSync: (tool: BuildTool, request: RequestId, offline: boolean, profiles: string[], onProgress: Channel<SyncProgress>) => typedError<BuildModel, IdeError>(__TAURI_INVOKE("build_sync", { tool, request, offline, profiles, onProgress })),
+	buildSync: (tool: BuildTool, request: RequestId, offline: boolean, profiles: string[], buildDir: string | null, onProgress: Channel<SyncProgress>) => typedError<BuildModel, IdeError>(__TAURI_INVOKE("build_sync", { tool, request, offline, profiles, buildDir, onProgress })),
 	/**  The resolved dependency tree of a Gradle project for one configuration (Dependency Analyzer). */
-	gradleDependencies: (gradlePath: string, configuration: string, offline: boolean, request: RequestId) => typedError<GradleDependency[], IdeError>(__TAURI_INVOKE("gradle_dependencies", { gradlePath, configuration, offline, request })),
+	gradleDependencies: (gradlePath: string, configuration: string, offline: boolean, request: RequestId, buildDir: string | null) => typedError<GradleDependency[], IdeError>(__TAURI_INVOKE("gradle_dependencies", { gradlePath, configuration, offline, request, buildDir })),
 	/**
 	 *  The `.toml` of a version catalog the build imports as `group:artifact:version`, once a
 	 *  build has downloaded it.
@@ -715,6 +730,8 @@ export const commands = {
 	debugCompletions: (session: DebugSessionId, frameId: number | null, text: string, line: number, column: number) => typedError<DebugCompletion[], IdeError>(__TAURI_INVOKE("debug_completions", { session, frameId, text, line, column })),
 	debugResume: (session: DebugSessionId, threadId: number) => typedError<null, IdeError>(__TAURI_INVOKE("debug_resume", { session, threadId })),
 	debugPause: (session: DebugSessionId, threadId: number) => typedError<null, IdeError>(__TAURI_INVOKE("debug_pause", { session, threadId })),
+	debugHotReload: (session: DebugSessionId) => typedError<null, IdeError>(__TAURI_INVOKE("debug_hot_reload", { session })),
+	debugHotRestart: (session: DebugSessionId) => typedError<null, IdeError>(__TAURI_INVOKE("debug_hot_restart", { session })),
 	debugStep: (session: DebugSessionId, threadId: number, kind: StepKind) => typedError<null, IdeError>(__TAURI_INVOKE("debug_step", { session, threadId, kind })),
 	debugRunTo: (session: DebugSessionId, threadId: number, path: string, line: number, force: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("debug_run_to", { session, threadId, path, line, force })),
 	debugStop: (session: DebugSessionId) => typedError<null, IdeError>(__TAURI_INVOKE("debug_stop", { session })),
@@ -784,10 +801,10 @@ export const commands = {
 	 */
 	windowOpenFileInNewWindow: (project: string | null, file: string) => typedError<OpenOutcome, IdeError>(__TAURI_INVOKE("window_open_file_in_new_window", { project, file })),
 	/**
-	 *  [`window_open_project`] for folder `path` on the host of SSH configuration
-	 *  `ssh_config` (Remote Development); a new window connects itself.
+	 *  [`window_open_project`] for folder `path` of `target` (an SSH host or a WSL distribution;
+	 *  Remote Development); a new window connects itself.
 	 */
-	windowOpenRemote: (sshConfig: string, path: string, newWindow: boolean) => typedError<OpenOutcome, IdeError>(__TAURI_INVOKE("window_open_remote", { sshConfig, path, newWindow })),
+	windowOpenRemote: (target: RemoteTarget, path: string, newWindow: boolean) => typedError<OpenOutcome, IdeError>(__TAURI_INVOKE("window_open_remote", { target, path, newWindow })),
 	/**  Opens an empty (welcome) window; returns its label. */
 	windowNew: () => typedError<string, IdeError>(__TAURI_INVOKE("window_new")),
 	/**
@@ -1131,6 +1148,19 @@ export const commands = {
 	dbTrustSshHost: (id: string) => typedError<null, IdeError>(__TAURI_INVOKE("db_trust_ssh_host", { id })),
 	/**  Test Connection: connects with `config` as edited (not necessarily saved). */
 	sshTest: (config: SshConfiguration, secret: string | null) => typedError<string, IdeError>(__TAURI_INVOKE("ssh_test", { config, secret })),
+	/**
+	 *  Installed WSL distros, for the "Connect to WSL" picker. `wsl.exe` can stall while the WSL
+	 *  service starts, so the wait is bounded.
+	 */
+	wslDistros: () => typedError<string[], IdeError>(__TAURI_INVOKE("wsl_distros")),
+	/**
+	 *  The WSL project a `\\wsl.localhost\<distro>\…` folder stands for, so the frontend opens it
+	 *  through the distro and not as a network folder. `None` for any other path.
+	 */
+	wslResolve: (path: string) => __TAURI_INVOKE<{
+	target: RemoteTarget,
+	path: string,
+} | null>("wsl_resolve", { path }),
 	/**  Remembers the password / passphrase of configuration `id` (`None` forgets it). */
 	sshSetSecret: (id: string, secret: string | null, save: boolean) => __TAURI_INVOKE<void>("ssh_set_secret", { id, secret, save }),
 	/**  Whether connecting with configuration `id` needs a password first. */
@@ -1173,15 +1203,17 @@ export const commands = {
 	/**  Browse before connecting, using the desktop's SSH configuration even in a remote window. */
 	remoteBootstrapList: (ssh: string, path: string) => typedError<RemoteEntry[], IdeError>(__TAURI_INVOKE("remote_bootstrap_list", { ssh, path })),
 	/**
-	 *  File › Remote Development: opens `path` on the host of SSH configuration
-	 *  `ssh_config` in this window (installs / starts the server as needed).
+	 *  File › Remote Development: opens `path` on `target` (an SSH host or a WSL distribution)
+	 *  in this window (installs / starts the server as needed).
 	 */
-	remoteConnect: (sshConfig: string, path: string, onProgress: Channel<RemoteProgress>) => typedError<RemoteProject_Serialize, IdeError>(__TAURI_INVOKE("remote_connect", { sshConfig, path, onProgress })),
+	remoteConnect: (target: RemoteTarget, path: string, onProgress: Channel<RemoteProgress>) => typedError<RemoteProject_Serialize, IdeError>(__TAURI_INVOKE("remote_connect", { target, path, onProgress })),
 	/**  The remote session of this window (a settings window: its parent's), if any. */
 	remoteCurrent: () => __TAURI_INVOKE<{
-	sshConfig: string,
+	target: RemoteTarget,
 	root: string,
 	host: string,
+	/**  `linux`, `macos` or `windows`: the OS the project's commands run on. */
+	os: string,
 	commands: string[],
 } | null>("remote_current"),
 	remoteDisconnect: () => __TAURI_INVOKE<void>("remote_disconnect"),
@@ -1231,7 +1263,7 @@ export const commands = {
 	dbSetManualCommit: (id: string, manual: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("db_set_manual_commit", { id, manual })),
 	dbFinishTransaction: (id: string, commit: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("db_finish_transaction", { id, commit })),
 	dbStatements: (id: string, text: string, from: number, to: number) => typedError<SqlStatement[], IdeError>(__TAURI_INVOKE("db_statements", { id, text, from, to })),
-	dbExecute: (request: RequestId, id: string, statements: SqlStatement[], maxRows: number) => typedError<DbStatementOutcome[], IdeError>(__TAURI_INVOKE("db_execute", { request, id, statements, maxRows })),
+	dbExecute: (request: RequestId, id: string, statements: SqlStatement[], skip: number, maxRows: number) => typedError<DbStatementOutcome[], IdeError>(__TAURI_INVOKE("db_execute", { request, id, statements, skip, maxRows })),
 	dbTablePage: (request: RequestId, id: string, schema: string, table: string, filter: string | null, sort: DbSortKey[], offset: number, limit: number) => typedError<DbTablePage, IdeError>(__TAURI_INVOKE("db_table_page", { request, id, schema, table, filter, sort, offset, limit })),
 	dbApplyEdits: (id: string, schema: string, table: string, edits: DbRowEdit[]) => typedError<number | null, IdeError>(__TAURI_INVOKE("db_apply_edits", { id, schema, table, edits })),
 	dbConsolePath: (id: string) => typedError<IpcPath, IdeError>(__TAURI_INVOKE("db_console_path", { id })),
@@ -1582,6 +1614,19 @@ export type AgentUsage = {
 	cost?: AgentCost | null,
 };
 
+/**  One entry of `adb devices -l`. */
+export type AndroidDevice = {
+	/**  `adb -s` value: a USB serial number, `emulator-5554`, or `host:port`. */
+	serial: string,
+	/**  `device` (usable), `offline`, `unauthorized` or `no permissions`. */
+	state: string,
+	model: string | null,
+	product: string | null,
+	/**  The device's own name from the build (`ro.product.device`). */
+	device: string | null,
+	transportId: string | null,
+};
+
 export type AppInfo = {
 	version: string,
 	platform: string,
@@ -1858,7 +1903,7 @@ export type BuildMessage = {
 /**  The build systems of a project; `None` when the project does not use one. */
 export type BuildModel = {
 	maven: MavenModel | null,
-	gradle: GradleModel | null,
+	gradle?: GradleModel[],
 };
 
 export type BuildResult = {
@@ -3924,6 +3969,8 @@ export type GradleRunUsing =
 
 /**  Build Tools › Gradle. */
 export type GradleSettings = {
+	/**  Linked build directories; absent preserves automatic discovery, empty unlinks all builds. */
+	linkedProjects?: string[] | null,
 	/**  Empty = Project JDK; otherwise a JDK home. */
 	jvm?: string,
 	distribution?: GradleDistribution,
@@ -4939,12 +4986,6 @@ export type LogDetails = {
 	fingerprint: string,
 };
 
-export type LogIndexProgress = {
-	indexed: number,
-	total: number,
-	running: boolean,
-};
-
 export type LogLevel = "debug" | "info" | "warn" | "error";
 
 export type LogLocation = {
@@ -5009,6 +5050,22 @@ export type LogQuery = {
 	stopAt?: string | null,
 };
 
+/**  The single-letter logcat priority, in increasing severity. */
+export type LogcatLevel = "verbose" | "debug" | "info" | "warn" | "error" | "fatal" | 
+/**  A line logcat prints outside the message format (`--------- beginning of main`). */
+"unknown";
+
+/**  One [`LogcatLevel`]-tagged line of `adb logcat -v threadtime`. */
+export type LogcatLine = {
+	/**  `MM-DD HH:MM:SS.mmm`, as logcat prints it (no year, device time zone). */
+	time: string,
+	pid: number,
+	tid: number,
+	level: LogcatLevel,
+	tag: string,
+	message: string,
+};
+
 export type LspRefreshKind = "inlayHints" | "semanticTokens" | "codeLens";
 
 export type MainToolbarSettings = {
@@ -5127,6 +5184,8 @@ export type MavenProject = {
 export type MavenSettings = {
 	/**  Project-relative root POMs removed from the Maven project model. */
 	unlinkedProjects?: string[],
+	/**  Project-relative POMs outside the root reactor added as independent top-level projects. */
+	linkedProjects?: string[],
 	/**  Maven home (or its `mvn` executable); empty = the project's `mvnw`, else `mvn` on `PATH`. */
 	home?: string,
 	/**  User `settings.xml` (`-s`); empty = `~/.m2/settings.xml`. */
@@ -5283,7 +5342,7 @@ export type NotebookEdit = { type: "setSource"; cell: string; source: string } |
 
 export type NotebookOutputEvent = {
 	id: string,
-	path: string,
+	path: IpcPath,
 	cell: string,
 	msgId: string,
 	kind: string,
@@ -5295,7 +5354,7 @@ export type NotebookOutputEvent = {
 
 export type NotebookSnapshot = {
 	id: string,
-	path: string,
+	path: IpcPath,
 	version: number,
 	dirty: boolean,
 	canUndo: boolean,
@@ -5497,7 +5556,11 @@ export type PluginEvent =
  *  Plugin languages, or the servers they may start, changed: re-fetch
  *  `languages` (the host re-detects open documents: [`crate::Host::plugin_languages_changed`]).
  */
-{ type: "languagesChanged" };
+{ type: "languagesChanged" } | 
+/**  Copy `text` to the system clipboard. */
+{ type: "copyToClipboard"; pluginId: string; text: string } | 
+/**  Open `url` (`http(s)://`) in the system browser. */
+{ type: "openUrl"; pluginId: string; url: string };
 
 export type PluginInfo = {
 	id: string,
@@ -5960,6 +6023,14 @@ export type RecentProject = {
 	branch: string | null,
 };
 
+/**  A named group of recent projects on the welcome screen (New Project Group…, Move to Group). */
+export type RecentProjectGroup = {
+	name: string,
+	/**  Its projects, in the order they were added. */
+	paths: IpcPath[],
+	expanded?: boolean,
+};
+
 export type RefactoringProblem = {
 	severity: ProblemSeverity,
 	message: string,
@@ -6010,6 +6081,8 @@ export type RegistryAgent = {
 	installed: string | null,
 	/**  Whether [`Self::version`] is newer than the installed one. */
 	update: boolean,
+	/**  An install of it is running (it goes on after the Settings page that started it closes). */
+	installing: boolean,
 };
 
 export type RegistryDistribution = 
@@ -6045,9 +6118,9 @@ export type RemoteEntry = {
 	permissions: string,
 };
 
-/**  A project folder on the host of an SSH configuration. */
+/**  A project folder on an SSH host or in a WSL distribution. */
 export type RemoteLaunch = {
-	sshConfig: string,
+	target: RemoteTarget,
 	path: string,
 };
 
@@ -6075,9 +6148,9 @@ export type RemoteProgress = {
 export type RemoteProject = RemoteProject_Serialize | RemoteProject_Deserialize;
 
 export type RemoteProject_Deserialize = {
-	sshConfig: string,
+	target: RemoteTarget,
 	root: string,
-	/**  `user@host:port` of the SSH configuration. */
+	/**  `user@host:port` of the SSH configuration; the distribution name for WSL. */
 	host: string,
 	serverVersion: string,
 	os: string,
@@ -6087,9 +6160,9 @@ export type RemoteProject_Deserialize = {
 };
 
 export type RemoteProject_Serialize = {
-	sshConfig: string,
+	target: RemoteTarget,
 	root: string,
-	/**  `user@host:port` of the SSH configuration. */
+	/**  `user@host:port` of the SSH configuration; the distribution name for WSL. */
 	host: string,
 	serverVersion: string,
 	os: string,
@@ -6099,15 +6172,24 @@ export type RemoteProject_Serialize = {
 };
 
 export type RemoteSession = {
-	sshConfig: string,
+	target: RemoteTarget,
 	root: string,
 	host: string,
+	/**  `linux`, `macos` or `windows`: the OS the project's commands run on. */
+	os: string,
 	commands: string[],
 };
 
 /**  Where [`remote_connect`] is (`fraction`: 0..1 of a download / upload). */
 export type RemoteStage = "connecting" | "checking" | "downloading" | "uploading" | "starting" | "opening";
 
+/**  Where a remote project lives and how the server there is reached. */
+export type RemoteTarget = 
+/**  The host of SSH configuration `config`. */
+{ kind: "ssh"; config: string } | 
+/**  A WSL distribution on this machine. */
+{ kind: "wsl"; distro: string };
+
 export type Renamed = {
 	edit: WorkspaceEdit,
 	incomplete: ReferencesIncomplete | null,
@@ -6193,7 +6275,7 @@ export type Risk =
 export type RootKind = "source" | "test" | "resources" | "testResources" | "excluded";
 
 export type RouteSource = {
-	path: string,
+	path: IpcPath,
 	text: string,
 };
 
diff --git a/src/editor/core/actions.ts b/src/editor/core/actions.ts
index d9c063773..ca1bd6ccc 100644
--- a/src/editor/core/actions.ts
+++ b/src/editor/core/actions.ts
@@ -63,7 +63,7 @@ import { cloneCaretAbove, cloneCaretBelow } from "./cm/verticalMotion";
 import { pasteAsPlainText, pasteFromHistory, unwrapAtCaret } from "./extras";
 import { cyclicExpandWord } from "./wordCompletion";
 import { qualifiedReference } from "./copyReference";
-import { symbolChain } from "./view/outline";
+import { declarationChain } from "./view/outline";
 import { recordClipboard } from "./clipboardHistory";
 import { useDocMeta, useOutline } from "./model/document";
 import { fontZoom, setFontZoom, stepFontZoom } from "./cm/prefs";
@@ -414,12 +414,14 @@ function copyReference(view: EditorView, slot: EditorSlot) {
   const line = state.doc.lineAt(head);
   const meta = slot.model.getMeta();
   const outline = useOutline.getState()[slot.model.path] ?? [];
+  // A package is not a member to qualify: jdtls lists the whole `package …;` statement as one.
+  const chain = declarationChain(outline, line.number - 1, head - line.from).filter((i) => i.kind !== "package");
   const reference = qualifiedReference({
     language: meta.language,
     path: slot.model.path,
     root: useProject.getState().project?.root ?? null,
     text: state.doc.toString(),
-    chain: symbolChain(outline, line.number - 1, head - line.from).map((i) => i.name),
+    chain: chain.map((i) => i.name),
     line: line.number - 1,
   });
   recordClipboard(reference);
diff --git a/src/editor/core/cm/highlight.ts b/src/editor/core/cm/highlight.ts
index d46306da1..4518a0874 100644
--- a/src/editor/core/cm/highlight.ts
+++ b/src/editor/core/cm/highlight.ts
@@ -9,17 +9,19 @@ import { tags as t, type Tag } from "@lezer/highlight";
 function token(
   tag: Tag | Tag[],
   name: string,
-  defaults: { italic?: string; bold?: string; effect?: string } = {},
+  defaults: { italic?: string; bold?: string; effect?: string; color?: string } = {},
 ): TagStyle {
+  const variable = (suffix: string, fallback: string) =>
+    `var(--syn-${name}${suffix}, ${defaults.color ? `var(--syn-${defaults.color}${suffix}, ${fallback})` : fallback})`;
   return {
     tag,
-    color: `var(--syn-${name})`,
-    fontStyle: `var(--syn-${name}-italic, ${defaults.italic ?? "inherit"})`,
-    fontWeight: `var(--syn-${name}-bold, ${defaults.bold ?? "inherit"})`,
-    backgroundColor: `var(--syn-${name}-bg, transparent)`,
-    textDecoration: `var(--syn-${name}-effect, ${defaults.effect ?? "none"})`,
+    color: defaults.color ? variable("", "inherit") : `var(--syn-${name})`,
+    fontStyle: variable("-italic", defaults.italic ?? "inherit"),
+    fontWeight: variable("-bold", defaults.bold ?? "inherit"),
+    backgroundColor: variable("-bg", "transparent"),
+    textDecoration: variable("-effect", defaults.effect ?? "none"),
     // WebKit takes a decoration with a style or colour only through the prefixed property.
-    WebkitTextDecoration: `var(--syn-${name}-effect, ${defaults.effect ?? "none"})`,
+    WebkitTextDecoration: variable("-effect", defaults.effect ?? "none"),
   };
 }
 
@@ -71,10 +73,12 @@ export const openideaHighlightStyle = HighlightStyle.define([
   token(t.special(t.brace), "decorator"),
   token([t.tagName, t.angleBracket], "tag"),
   token([t.punctuation, t.bracket, t.separator, t.operator, t.derefOperator], "punct"),
+  token(t.bracket, "bracket", { color: "punct" }),
+  token(t.separator, "separator", { color: "punct" }),
   token(t.invalid, "invalid"),
   // Markup (Markdown, docs)
   token(t.heading, "markup-heading", { bold: "var(--fw-code-bold, 700)" }),
-  token(t.processingInstruction, "keyword"),
+  token(t.processingInstruction, "processing-instruction", { color: "keyword" }),
   { tag: t.emphasis, fontStyle: "italic" },
   { tag: t.strong, fontWeight: "var(--fw-code-bold, 700)" },
   { tag: t.strikethrough, textDecoration: "line-through" },
diff --git a/src/editor/core/cm/lanes.ts b/src/editor/core/cm/lanes.ts
index 68a2e6c37..0a89e1f60 100644
--- a/src/editor/core/cm/lanes.ts
+++ b/src/editor/core/cm/lanes.ts
@@ -65,8 +65,8 @@ class OverviewLane {
   /** The last pointer position over the editor, to re-check the thumb when it scrolls. */
   private pointer: { x: number; y: number } | null = null;
   /**
-   * The scrollbar thumb drawn over the marks: the native one sits under the lane, so a mark
-   * the height of the lane (a new file) would hide it (#1014).
+   * The scrollbar thumb, drawn and dragged by the lane: the native scrollbar is hidden, so a
+   * press on this strip stays here instead of reaching the text layer as a text drag.
    */
   private thumb: HTMLElement;
 
@@ -77,6 +77,7 @@ class OverviewLane {
     this.thumb = document.createElement("div");
     this.thumb.className = "cm-openidea-overviewThumb";
     this.dom.addEventListener("mousedown", this.onMouseDown);
+    this.thumb.addEventListener("mousedown", this.onThumbMouseDown);
     view.dom.addEventListener("mousemove", this.onPointerMove);
     view.dom.addEventListener("mouseleave", this.onPointerLeave);
     view.scrollDOM.addEventListener("scroll", this.onScroll, { passive: true });
@@ -175,8 +176,8 @@ class OverviewLane {
         const thumb = scrollbarThumb(s.scrollTop, s.scrollHeight, s.clientHeight);
         // The lane starts at the top of the editor, the scrollbar at the top of the scroller.
         const offset = s.getBoundingClientRect().top - this.dom.getBoundingClientRect().top;
-        // Inset by the thumb's 2px transparent border (global.css).
-        return thumb && { top: thumb.top + offset + 2, height: thumb.bottom - thumb.top - 4 };
+        // The drawn thumb matches the geometry the drag maps onto, so the pointer keeps its grip.
+        return thumb && { top: thumb.top + offset, height: thumb.bottom - thumb.top };
       },
       write: (thumb) => {
         this.thumb.style.display = thumb ? "" : "none";
@@ -188,8 +189,8 @@ class OverviewLane {
   }
 
   /**
-   * Over the scrollbar thumb the marks let the pointer through, so the thumb can be dragged
-   * even where a mark covers it (a new file is one mark the height of the lane, #752).
+   * Over the thumb the marks let the pointer through, so the thumb can be dragged even where a
+   * mark covers it (a new file is one mark the height of the lane, #752).
    */
   private updateThumbPassThrough() {
     const p = this.pointer;
@@ -220,6 +221,31 @@ class OverviewLane {
     if (this.pointer) this.updateThumbPassThrough();
   };
 
+  /** The thumb's own press: drag it, keeping the button state inside the lane. */
+  private onThumbMouseDown = (e: MouseEvent) => {
+    if (e.button !== 0) return;
+    e.preventDefault();
+    e.stopPropagation();
+    const s = this.view.scrollDOM;
+    const thumb = scrollbarThumb(s.scrollTop, s.scrollHeight, s.clientHeight);
+    if (!thumb) return;
+    const startY = e.clientY;
+    const startTop = s.scrollTop;
+    const travel = s.scrollHeight - s.clientHeight;
+    // The distance the thumb can move: the track minus the thumb itself.
+    const track = Math.max(1, s.clientHeight - (thumb.bottom - thumb.top));
+    const onMove = (ev: MouseEvent) => {
+      s.scrollTop = startTop + ((ev.clientY - startY) * travel) / track;
+    };
+    const onUp = () => {
+      window.removeEventListener("mousemove", onMove);
+      window.removeEventListener("mouseup", onUp);
+      this.updateThumbPassThrough();
+    };
+    window.addEventListener("mousemove", onMove);
+    window.addEventListener("mouseup", onUp);
+  };
+
   private onMouseDown = (e: MouseEvent) => {
     if (e.button !== 0) return;
     const marks = [...this.dom.querySelectorAll<HTMLElement>(".cm-openidea-overviewMark")].map((el) => {
@@ -227,7 +253,17 @@ class OverviewLane {
       return { top: r.top, bottom: r.bottom, pos: Number(el.dataset.pos) };
     });
     const hit = nearestMark(marks, e.clientY);
-    if (!hit) return;
+    if (!hit) {
+      // Above / below the thumb pages the editor, like the native track it replaces.
+      const s = this.view.scrollDOM;
+      const thumb = scrollbarThumb(s.scrollTop, s.scrollHeight, s.clientHeight);
+      e.preventDefault();
+      if (!thumb) return;
+      const y = e.clientY - s.getBoundingClientRect().top;
+      if (y < thumb.top) s.scrollTop -= s.clientHeight;
+      else if (y > thumb.bottom) s.scrollTop += s.clientHeight;
+      return;
+    }
     e.preventDefault();
     const state = this.view.state;
     const pos = Math.min(hit.pos, state.doc.length);
@@ -241,6 +277,7 @@ class OverviewLane {
 
   destroy() {
     this.dom.removeEventListener("mousedown", this.onMouseDown);
+    this.thumb.removeEventListener("mousedown", this.onThumbMouseDown);
     this.view.dom.removeEventListener("mousemove", this.onPointerMove);
     this.view.dom.removeEventListener("mouseleave", this.onPointerLeave);
     this.view.scrollDOM.removeEventListener("scroll", this.onScroll);
diff --git a/src/editor/core/cm/languages.test.ts b/src/editor/core/cm/languages.test.ts
index 72d674ea7..5ca460d6f 100644
--- a/src/editor/core/cm/languages.test.ts
+++ b/src/editor/core/cm/languages.test.ts
@@ -3,6 +3,51 @@ import { highlightTree, tagHighlighter, tags as t } from "@lezer/highlight";
 import { findLanguageDescription, loadSupport } from "./languages";
 
 describe("language modes", () => {
+  it("distinguishes PHP classes, method declarations and fields for imported schemes", async () => {
+    const support = await loadSupport(findLanguageDescription("PHP", "/tmp/palette.php")!);
+    const source = "<?php class Palette extends BasePalette { var $name; function example() {} }";
+    const found: Array<[string, string]> = [];
+    highlightTree(
+      support!.language.parser.parse(source),
+      tagHighlighter([
+        { tag: t.className, class: "class" },
+        { tag: t.function(t.definition(t.variableName)), class: "function" },
+        { tag: t.definition(t.propertyName), class: "field" },
+      ]),
+      (from, to, style) => found.push([source.slice(from, to), style]),
+    );
+    expect(found).toEqual([
+      ["Palette", "class"],
+      ["BasePalette", "class"],
+      ["$name", "field"],
+      ["example", "function"],
+    ]);
+  });
+
+  it("parses YAML into large tree buffers and highlights mappings after comment lines", async () => {
+    for (const path of ["/p/application.yml", "/p/compose.yaml"]) {
+      const support = await loadSupport(findLanguageDescription("YAML", path)!);
+      // @lezer/yaml can invert a node's range on a tree buffer boundary; one buffer avoids it.
+      expect((support!.language.parser as unknown as { bufferLength: number }).bufferLength).toBe(1 << 16);
+    }
+    const support = await loadSupport(findLanguageDescription("YAML", "/p/application.yml")!);
+    const source = "spring:\n  datasource:\n  # driver: a\n  # url: b\n    driver: c # d\n    url: e\n";
+    const found: Array<[string, string]> = [];
+    highlightTree(
+      support!.language.parser.parse(source),
+      tagHighlighter([
+        { tag: t.lineComment, class: "comment" },
+        { tag: t.definition(t.propertyName), class: "key" },
+      ]),
+      (from, to, style) => found.push([source.slice(from, to), style]),
+    );
+    expect(found.filter(([, style]) => style === "comment").map(([text]) => text)).toEqual([
+      "# driver: a",
+      "# url: b",
+      "# d",
+    ]);
+  });
+
   it("recognizes AsciiDoc files and loads their lightweight syntax mode", async () => {
     for (const path of ["/docs/guide.adoc", "/docs/guide.asciidoc"]) {
       const description = findLanguageDescription("AsciiDoc", path);
diff --git a/src/editor/core/cm/languages.ts b/src/editor/core/cm/languages.ts
index ddff2757a..5bf648488 100644
--- a/src/editor/core/cm/languages.ts
+++ b/src/editor/core/cm/languages.ts
@@ -5,6 +5,7 @@
  * and indentation fall back to the backend definition when the mode lacks them.
  */
 import { EditorState, Prec, type Extension } from "@codemirror/state";
+import { EditorView } from "@codemirror/view";
 import {
   LRLanguage,
   LanguageDescription,
@@ -114,6 +115,21 @@ const OWN_MODES = [
     load: () => import("./erb").then((m) => m.erb()),
   }),
   LanguageDescription.of({ name: "JSP", load: () => import("./jsp").then((m) => m.jsp()) }),
+  LanguageDescription.of({
+    name: "YAML",
+    alias: ["yml"],
+    extensions: ["yaml", "yml"],
+    load: async () => {
+      const support = await languageData.find((l) => l.name === "YAML")!.load();
+      // @lezer/yaml can give a mapping that follows comment lines an inverted range when it
+      // lands on a tree buffer boundary (1024 entries by default); highlighting then skips
+      // the whole mapping. Larger buffers keep ordinary YAML files in one.
+      return new LanguageSupport(
+        (support.language as LRLanguage).configure({ bufferLength: 1 << 16 }),
+        support.support,
+      );
+    },
+  }),
 ];
 
 const BATCH_KEYWORDS = new Set([
@@ -246,6 +262,12 @@ const EXTRA_TAGS: Record<string, Parameters<typeof styleTags>[0]> = {
   JSX: JS_TAGS,
   TSX: JS_TAGS,
   Java: JAVA_TAGS,
+  PHP: {
+    "; ,": t.separator,
+    "ClassDeclaration/Name BaseClause/Name InterfaceClause/Name": t.className,
+    "MethodDeclaration/Name FunctionDefinition/Name": t.function(t.definition(t.variableName)),
+    "PropertyDeclaration/VariableDeclarator/VariableName": t.definition(t.propertyName),
+  },
   CSS: CSS_TAGS,
   SCSS: CSS_TAGS,
   Sass: CSS_TAGS,
@@ -255,8 +277,14 @@ const EXTRA_TAGS: Record<string, Parameters<typeof styleTags>[0]> = {
 
 function patchSupport(desc: LanguageDescription, support: LanguageSupport): LanguageSupport {
   const extra = EXTRA_TAGS[desc.name];
-  if (!extra || !(support.language instanceof LRLanguage)) return support;
-  const patched = new LanguageSupport(support.language.configure({ props: [styleTags(extra)] }), support.support);
+  const language =
+    extra && support.language instanceof LRLanguage
+      ? support.language.configure({ props: [styleTags(extra)] })
+      : support.language;
+  const patched = new LanguageSupport(language, [
+    support.support,
+    EditorView.editorAttributes.of({ "data-language": desc.name }),
+  ]);
   // `loadedSupport` reads `desc.support` synchronously; keep it on the patched instance.
   (desc as { support: LanguageSupport | undefined }).support = patched;
   return patched;
diff --git a/src/editor/core/cm/prefs.ts b/src/editor/core/cm/prefs.ts
index 333a054b2..81fd80ee1 100644
--- a/src/editor/core/cm/prefs.ts
+++ b/src/editor/core/cm/prefs.ts
@@ -34,6 +34,7 @@ import {
   selectLineStart,
 } from "@codemirror/commands";
 import { markdownImages } from "./markdownImages";
+import { selectionMarks } from "./selectionMarks";
 import type { EditorExtras } from "@/platform/editorSettings";
 import { openideaHighlightStyle } from "./highlight";
 import {
@@ -504,6 +505,7 @@ export function caretExtension(prefs: EditorExtras): Extension {
     // Before drawSelection: its measure request must run before the cursor layer redraws.
     a.smoothCaretMovement ? caretGlide : [],
     drawSelection({ cursorBlinkRate: a.caretBlinking ? Math.max(100, Math.min(5000, a.caretBlinkPeriod)) * 2 : 0 }),
+    selectionMarks,
     classes.length ? EditorView.editorAttributes.of({ class: classes.join(" ") }) : [],
   ];
 }
diff --git a/src/editor/core/cm/selectionMarks.test.ts b/src/editor/core/cm/selectionMarks.test.ts
new file mode 100644
index 000000000..7c3c2e777
--- /dev/null
+++ b/src/editor/core/cm/selectionMarks.test.ts
@@ -0,0 +1,57 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { EditorSelection, EditorState, Prec, type Extension } from "@codemirror/state";
+import { Decoration, EditorView } from "@codemirror/view";
+import { selectionMarks } from "./selectionMarks";
+
+const views: EditorView[] = [];
+afterEach(() => views.splice(0).forEach((v) => v.destroy()));
+
+function view(doc: string, selection: EditorSelection, extensions: Extension) {
+  extensions = [EditorState.allowMultipleSelections.of(true), extensions];
+  const parent = document.createElement("div");
+  document.body.appendChild(parent);
+  const v = new EditorView({ state: EditorState.create({ doc, selection, extensions }), parent });
+  views.push(v);
+  return v;
+}
+
+/** A background mark as features add it (lint range, find match, usage, semantic bg…). */
+const backgroundMark = (cls: string, from: number, to: number, prec: (e: Extension) => Extension = (e) => e) =>
+  prec(EditorView.decorations.of(Decoration.set(Decoration.mark({ class: cls }).range(from, to))));
+
+const DOC = "return request.app.state.credits";
+
+describe("selectionMarks", () => {
+  it.each([
+    ["default", (e: Extension) => e],
+    ["high (Lezer highlighter)", Prec.high],
+    ["lowest", Prec.lowest],
+  ])("paints selected text inside a %s-precedence background mark", (_, prec) => {
+    // The reporter's case: a light-scheme warning background over `request.app.state.credits`.
+    const v = view(DOC, EditorSelection.single(7, DOC.length), [
+      backgroundMark("cm-lintRange-warning", 7, DOC.length, prec),
+      selectionMarks,
+    ]);
+    const selected = [...v.contentDOM.querySelectorAll(".cm-openidea-selected")];
+    expect(selected.map((e) => e.textContent).join("")).toBe(DOC.slice(7));
+    for (const el of selected) expect(el.closest(".cm-lintRange-warning")).not.toBeNull();
+  });
+
+  it("covers every range of a multi-selection, partially overlapping marks too", () => {
+    const v = view(DOC, EditorSelection.create([EditorSelection.range(0, 3), EditorSelection.range(10, 20)], 1), [
+      backgroundMark("cm-openidea-findMatch", 15, 24),
+      selectionMarks,
+    ]);
+    const text = [...v.contentDOM.querySelectorAll(".cm-openidea-selected")].map((e) => e.textContent).join("|");
+    expect(text.replace(/\|/g, "")).toBe(DOC.slice(0, 3) + DOC.slice(10, 20));
+    const inMatch = [...v.contentDOM.querySelectorAll(".cm-openidea-findMatch .cm-openidea-selected")];
+    expect(inMatch.map((e) => e.textContent).join("")).toBe(DOC.slice(15, 20));
+  });
+
+  it("adds nothing for an empty selection and clears when the selection collapses", () => {
+    const v = view(DOC, EditorSelection.single(0, 6), [selectionMarks]);
+    expect(v.contentDOM.querySelector(".cm-openidea-selected")).not.toBeNull();
+    v.dispatch({ selection: EditorSelection.cursor(3) });
+    expect(v.contentDOM.querySelector(".cm-openidea-selected")).toBeNull();
+  });
+});
diff --git a/src/editor/core/cm/selectionMarks.ts b/src/editor/core/cm/selectionMarks.ts
new file mode 100644
index 000000000..eadee2ce9
--- /dev/null
+++ b/src/editor/core/cm/selectionMarks.ts
@@ -0,0 +1,47 @@
+import { Prec, RangeSetBuilder, type Extension } from "@codemirror/state";
+import { Decoration, EditorView, ViewPlugin, type DecorationSet, type ViewUpdate } from "@codemirror/view";
+
+/**
+ * `drawSelection` paints the selection in a layer behind the text, so any mark with its own
+ * background (light-scheme warnings, find matches, usages, semantic backgrounds…) hides it.
+ * This repaints selected text in the innermost span: higher-precedence marks nest closer to the
+ * text, and the only other `Prec.highest` marks (LSP semantic tokens) set colour, not background.
+ */
+const selectedMark = Decoration.mark({ class: "cm-openidea-selected" });
+
+function selectedRanges(view: EditorView): DecorationSet {
+  const builder = new RangeSetBuilder<Decoration>();
+  const ranges = view.state.selection.ranges.filter((r) => !r.empty);
+  if (!ranges.length) return Decoration.none;
+  for (const { from: vFrom, to: vTo } of view.visibleRanges)
+    for (const r of ranges) {
+      const from = Math.max(r.from, vFrom);
+      const to = Math.min(r.to, vTo);
+      if (from < to) builder.add(from, to, selectedMark);
+    }
+  return builder.finish();
+}
+
+const plugin = ViewPlugin.fromClass(
+  class {
+    decorations: DecorationSet;
+    constructor(view: EditorView) {
+      this.decorations = selectedRanges(view);
+    }
+    update(u: ViewUpdate) {
+      if (u.selectionSet || u.docChanged || u.viewportChanged) this.decorations = selectedRanges(u.view);
+    }
+  },
+  { decorations: (p) => p.decorations },
+);
+
+const theme = EditorView.baseTheme({
+  ".cm-openidea-selected": {
+    backgroundColor: "var(--editor-selection-inactive, var(--bg-editor-selection-inactive))",
+  },
+  "&.cm-focused .cm-openidea-selected": {
+    backgroundColor: "var(--editor-selection, var(--bg-editor-selection))",
+  },
+});
+
+export const selectionMarks: Extension = [Prec.highest(plugin), theme];
diff --git a/src/editor/core/cm/theme.ts b/src/editor/core/cm/theme.ts
index 8bb129fae..909a80829 100644
--- a/src/editor/core/cm/theme.ts
+++ b/src/editor/core/cm/theme.ts
@@ -267,14 +267,14 @@ export const openideaTheme = EditorView.theme({
   ".cm-panels.cm-panels-top": { borderBottom: "1px solid var(--border)" },
   ".cm-panels.cm-panels-bottom": { borderTop: "1px solid var(--border)" },
 
-  // Error stripe over the scrollbar (cm/lanes.ts)
+  // Error stripe and scrollbar lane (cm/lanes.ts)
   ".cm-openidea-overview": {
     position: "absolute",
     top: "0",
     right: "0",
     bottom: "0",
     width: "12px",
-    pointerEvents: "none",
+    cursor: "default",
     zIndex: "3",
   },
   ".cm-openidea-overviewMark": {
@@ -289,15 +289,17 @@ export const openideaTheme = EditorView.theme({
   ".cm-openidea-overviewMark-thin": { left: "4px", width: "4px", minHeight: "2px" },
   // The scrollbar thumb wins over the marks under it (cm/lanes.ts, #752).
   ".cm-openidea-overview-onThumb .cm-openidea-overviewMark": { pointerEvents: "none" },
-  // The lane draws the thumb over its marks (#1014); the native one only takes the drag.
-  "&.cm-openidea-withOverview .cm-scroller::-webkit-scrollbar-thumb:vertical": { backgroundColor: "transparent" },
+  // The lane owns the scrollbar and its thumb (cm/lanes.ts): the native one is hidden so a press
+  // on the scrollbar can never reach the text layer and start a text selection.
+  "&.cm-openidea-withOverview .cm-scroller::-webkit-scrollbar:vertical": { width: "0" },
   ".cm-openidea-overviewThumb": {
     position: "absolute",
     right: "2px",
     width: "6px",
     borderRadius: "3px",
     background: "var(--scrollbar-thumb)",
-    pointerEvents: "none",
+    pointerEvents: "auto",
+    cursor: "default",
   },
   ".cm-openidea-overview-onThumb .cm-openidea-overviewThumb": { background: "var(--scrollbar-thumb-hover)" },
   ".cm-openidea-overviewCaret": {
@@ -305,6 +307,7 @@ export const openideaTheme = EditorView.theme({
     left: "2px",
     right: "2px",
     height: "2px",
+    pointerEvents: "none",
     background: "color-mix(in srgb, var(--fg) 30%, transparent)",
   },
 
diff --git a/src/editor/core/copyReference.ts b/src/editor/core/copyReference.ts
index 9684fd25b..953a73f94 100644
--- a/src/editor/core/copyReference.ts
+++ b/src/editor/core/copyReference.ts
@@ -1,7 +1,7 @@
 /**
- * Edit › Copy Reference (⌥⇧⌘C): the fully qualified name of the symbol at
- * the caret, built from the file's outline (symbols enclosing the caret) and
- * the language's module conventions; `path:line` where there is no symbol.
+ * Edit › Copy Reference (⌥⇧⌘C): with the caret on a declaration's name, its
+ * fully qualified name, built from the file's outline and the language's module
+ * conventions; anywhere else `path:line`, as in IDEA.
  */
 
 export interface ReferenceInput {
@@ -11,7 +11,7 @@ export interface ReferenceInput {
   /** Project root, for project-relative paths and module names. */
   root: string | null;
   text: string;
-  /** Names of the outline symbols enclosing the caret, outermost first. */
+  /** Names of the outline symbols down to the one named at the caret, outermost first; empty off a name. */
   chain: string[];
   /** 0-based caret line. */
   line: number;
@@ -59,42 +59,37 @@ const declared = (text: string, re: RegExp) => re.exec(text)?.[1] ?? null;
 export function qualifiedReference(r: ReferenceInput): string {
   const fallback = `${relativePath(r.path, r.root)}:${r.line + 1}`;
   const chain = r.chain.filter(Boolean);
+  if (!chain.length) return fallback;
   switch (r.language) {
     case "java":
     case "groovy": {
-      if (!chain.length) return fallback;
       const pkg = declared(r.text, /^\s*package\s+([\w.]+)\s*;?/m);
       const [type, ...rest] = chain;
       const typePath = [pkg, type].filter(Boolean).join(".");
-      // `pkg.Outer.Inner#member`: the last symbol is the member unless the caret is in a type only.
+      // `pkg.Outer.Inner#member`: the last symbol is the member unless the caret is on a type's name.
       return rest.length ? `${[typePath, ...rest.slice(0, -1)].join(".")}#${rest[rest.length - 1]}` : typePath;
     }
     case "kotlin":
     case "scala": {
-      if (!chain.length) return fallback;
       const pkg = declared(r.text, /^\s*package\s+([\w.]+)/m);
       return [pkg, ...chain].filter(Boolean).join(".");
     }
-    case "csharp": {
-      if (!chain.length) return fallback;
+    case "csharp":
       return chain.join(".");
-    }
-    case "rust": {
-      if (!chain.length) return rustModulePath(r.path);
+    case "rust":
       return [rustModulePath(r.path), ...chain.map((n) => (n.startsWith("impl") ? rustImplType(n) : n))].join("::");
-    }
     case "python":
       return [pythonModulePath(r.path, r.root), ...chain].join(".");
     case "go": {
       const pkg = declared(r.text, /^\s*package\s+(\w+)/m) ?? stem(r.path);
-      return chain.length ? [pkg, ...chain].join(".") : fallback;
+      return [pkg, ...chain].join(".");
     }
     case "cpp":
     case "c":
     case "objective-cpp":
     case "php":
-      return chain.length ? chain.join("::") : fallback;
+      return chain.join("::");
     default:
-      return chain.length ? `${relativePath(r.path, r.root)}:${chain.join(".")}` : fallback;
+      return `${relativePath(r.path, r.root)}:${chain.join(".")}`;
   }
 }
diff --git a/src/editor/core/editingExtras.test.ts b/src/editor/core/editingExtras.test.ts
index 8c9676f8c..d1ead564c 100644
--- a/src/editor/core/editingExtras.test.ts
+++ b/src/editor/core/editingExtras.test.ts
@@ -2,7 +2,9 @@ import { describe, expect, it } from "vitest";
 import { EditorState } from "@codemirror/state";
 import { EditorView } from "@codemirror/view";
 import { cyclicExpandWord, expandCandidates, prefixStart } from "./wordCompletion";
+import type { OutlineItem } from "@/platform/ipc";
 import { pythonModulePath, qualifiedReference, rustImplType, rustModulePath } from "./copyReference";
+import { declarationChain } from "./view/outline";
 
 describe("cyclic expand word", () => {
   const text = "alphaOne x alphaTwo y al| alphaThree alphaOne";
@@ -101,5 +103,33 @@ describe("copy reference", () => {
     expect(
       qualifiedReference({ ...base, root: null, language: "markdown", path: "/x/a.md", text: "", chain: [] }),
     ).toBe("/x/a.md:5");
+    expect(qualifiedReference({ ...base, language: "python", path: "/p/pkg/mod.py", text: "", chain: [] })).toBe(
+      "pkg/mod.py:5",
+    );
+    expect(qualifiedReference({ ...base, language: "rust", path: "/p/src/a.rs", text: "", chain: [] })).toBe(
+      "src/a.rs:5",
+    );
+  });
+
+  it("names a symbol only with the caret on its name, like IDEA", () => {
+    const item = (name: string, range: number[], sel: number[], children: OutlineItem[] = []): OutlineItem => ({
+      name,
+      detail: null,
+      kind: "class",
+      range: { start: { line: range[0]!, col: range[1]! }, end: { line: range[2]!, col: range[3]! } },
+      selection_range: { start: { line: sel[0]!, col: sel[1]! }, end: { line: sel[2]!, col: sel[3]! } },
+      children,
+    });
+    // class Book {        line 0, name at cols 6-10
+    //   void sum() {      line 1, name at cols 7-10
+    //     total += 1;     line 2
+    const outline = [item("Book", [0, 0, 4, 1], [0, 6, 0, 10], [item("sum", [1, 2, 3, 3], [1, 7, 1, 10])])];
+    const names = (line: number, col: number) => declarationChain(outline, line, col).map((i) => i.name);
+    expect(names(1, 8)).toEqual(["Book", "sum"]);
+    expect(names(1, 10)).toEqual(["Book", "sum"]);
+    expect(names(0, 6)).toEqual(["Book"]);
+    expect(names(2, 6)).toEqual([]);
+    expect(names(1, 2)).toEqual([]);
+    expect(names(5, 0)).toEqual([]);
   });
 });
diff --git a/src/editor/core/view/outline.ts b/src/editor/core/view/outline.ts
index 79451cfe8..ebcc9876d 100644
--- a/src/editor/core/view/outline.ts
+++ b/src/editor/core/view/outline.ts
@@ -14,3 +14,11 @@ export function symbolChain(items: readonly OutlineItem[], line: number, col: nu
     level = hit.children;
   }
 }
+
+/** The chain up to the innermost item whose name (selection range) holds (line, col); empty off every name. */
+export function declarationChain(items: readonly OutlineItem[], line: number, col: number): OutlineItem[] {
+  const pos = { line, col };
+  const chain = symbolChain(items, line, col);
+  const named = chain.findLastIndex((i) => before(i.selection_range.start, pos) && before(pos, i.selection_range.end));
+  return chain.slice(0, named + 1);
+}
diff --git a/src/editor/lsp/theme.ts b/src/editor/lsp/theme.ts
index aff186e7a..8ea732ac7 100644
--- a/src/editor/lsp/theme.ts
+++ b/src/editor/lsp/theme.ts
@@ -365,6 +365,14 @@ export const lspTheme = EditorView.theme({
   ".cm-sem-global:not(.cm-sem-function)": { color: "var(--syn-global, inherit)" },
   ".cm-sem-builtin:not(.cm-sem-function)": { color: "var(--syn-builtin, inherit)" },
   ".cm-sem-static": { fontStyle: "var(--syn-static-italic, italic)" },
+  ".cm-sem-property.cm-sem-static, .cm-sem-property.cm-sem-static *": {
+    color: "var(--syn-static-property, var(--syn-property))",
+    fontStyle: "var(--syn-static-property-italic, var(--syn-static-italic, italic))",
+    fontWeight: "var(--syn-static-property-bold, var(--syn-property-bold, inherit))",
+    backgroundColor: "var(--syn-static-property-bg, transparent)",
+    textDecoration: "var(--syn-static-property-effect, none)",
+    WebkitTextDecoration: "var(--syn-static-property-effect, none)",
+  },
   ".cm-sem-python-static": { fontStyle: "var(--syn-python-static-italic, normal)" },
   ".cm-sem-mutable": {
     textDecoration: "underline",
diff --git a/src/features/agents/AgentRegistryPage.tsx b/src/features/agents/AgentRegistryPage.tsx
index a7644a83b..d3910cb60 100644
--- a/src/features/agents/AgentRegistryPage.tsx
+++ b/src/features/agents/AgentRegistryPage.tsx
@@ -1,9 +1,10 @@
 /**
  * Settings › Tools › Agents: the launch command of built-in agents (Claude Code…), and
  * agents of the ACP Registry this machine can run, with Install / Update / Remove.
- * Installs run in the background with progress; leaving the page cancels one.
+ * Installs run in the background with progress, and keep running after the page closes
+ * (as a background task of the project windows); the page then shows them as installing.
  */
-import { useEffect, useMemo, useRef, useState } from "react";
+import { useEffect, useMemo, useState } from "react";
 import type { AgentRegistry, RegistryAgent, RequestId } from "@/bindings";
 import { isCancelled, nextRequestId } from "@/platform/ipc";
 import { tx } from "@/platform/i18n";
@@ -28,13 +29,26 @@ import styles from "./AgentRegistry.module.css";
 
 const errorText = (e: unknown) => (e instanceof Error ? e.message : String(e));
 
+/** How often the page checks on installs it did not start. */
+const BACKGROUND_POLL_MS = 1500;
+
 interface Job {
   id: string;
-  request: RequestId;
   fraction: number | null;
   message: string;
 }
 
+interface PageJob extends Job {
+  request: RequestId;
+}
+
+/** An install started before the page opened; its progress shows in the background tasks. */
+const backgroundJob = (agent: RegistryAgent): Job => ({
+  id: agent.id,
+  fraction: null,
+  message: tx`Installing ${agent.name} in the background…`,
+});
+
 export function AgentRegistryPage({
   onChanged,
   backend = tauriRegistry,
@@ -72,7 +86,7 @@ function RegistryList({ backend, onChanged }: { backend: RegistryBackend; onChan
   const [registry, setRegistry] = useState<AgentRegistry | null>(null);
   const [loadError, setLoadError] = useState<string | null>(null);
   const [query, setQuery] = useState("");
-  const [job, setJob] = useState<Job | null>(null);
+  const [job, setJob] = useState<PageJob | null>(null);
   const [removing, setRemoving] = useState<string | null>(null);
   const [errors, setErrors] = useState<Record<string, string>>({});
 
@@ -89,11 +103,39 @@ function RegistryList({ backend, onChanged }: { backend: RegistryBackend; onChan
     };
   }, [backend]);
 
+  // Installs started before the page opened: follow them until they end.
+  const background = registry?.agents.some((a) => a.installing) ?? false;
+  useEffect(() => {
+    if (!background) return;
+    let live = true;
+    let request: RequestId | null = null;
+    const timer = setInterval(() => {
+      if (request != null) return;
+      const r = (request = nextRequestId());
+      backend
+        .list(r)
+        .then((next) => {
+          if (!live) return;
+          setRegistry(next);
+          if (!next.agents.some((a) => a.installing)) onChanged?.();
+        })
+        .catch(() => {})
+        .finally(() => {
+          if (request === r) request = null;
+        });
+    }, BACKGROUND_POLL_MS);
+    return () => {
+      live = false;
+      clearInterval(timer);
+      if (request != null) backend.cancel(request);
+    };
+  }, [backend, background, onChanged]);
+
   const agents = useMemo(
     () => sortAgents((registry?.agents ?? []).filter((a) => matchesQuery(a, query))),
     [registry, query],
   );
-  const busy = job != null || removing != null;
+  const busy = job != null || removing != null || background;
 
   const setError = (id: string, error: string | null) =>
     setErrors((all) => {
@@ -101,9 +143,6 @@ function RegistryList({ backend, onChanged }: { backend: RegistryBackend; onChan
       return error ? { ...rest, [id]: error } : rest;
     });
 
-  // The install in progress, for leaving the page.
-  const running = useRef<RequestId | null>(null);
-
   const install = async (agent: RegistryAgent) => {
     if (
       agent.noChecksum &&
@@ -116,7 +155,6 @@ function RegistryList({ backend, onChanged }: { backend: RegistryBackend; onChan
     )
       return;
     const request = nextRequestId();
-    running.current = request;
     setError(agent.id, null);
     setJob({ id: agent.id, request, fraction: null, message: tx`Installing ${agent.name} ${agent.version}…` });
     backend
@@ -134,10 +172,7 @@ function RegistryList({ backend, onChanged }: { backend: RegistryBackend; onChan
         onChanged?.();
       })
       .catch((e: unknown) => !isCancelled(e) && setError(agent.id, errorText(e)))
-      .finally(() => {
-        if (running.current === request) running.current = null;
-        setJob(null);
-      });
+      .finally(() => setJob(null));
   };
 
   const remove = (agent: RegistryAgent) => {
@@ -153,14 +188,6 @@ function RegistryList({ backend, onChanged }: { backend: RegistryBackend; onChan
       .finally(() => setRemoving(null));
   };
 
-  // Leaving the page stops an install.
-  useEffect(
-    () => () => {
-      if (running.current != null) backend.cancel(running.current);
-    },
-    [backend],
-  );
-
   return (
     <div className={styles.body}>
       <SearchField
@@ -202,13 +229,13 @@ function RegistryList({ backend, onChanged }: { backend: RegistryBackend; onChan
               <AgentRow
                 key={agent.id}
                 agent={agent}
-                job={job?.id === agent.id ? job : null}
+                job={job?.id === agent.id ? job : agent.installing ? backgroundJob(agent) : null}
                 removing={removing === agent.id}
                 disabled={busy}
                 error={errors[agent.id] ?? null}
                 onInstall={() => void install(agent)}
                 onRemove={() => remove(agent)}
-                onCancel={() => job && backend.cancel(job.request)}
+                onCancel={job?.id === agent.id ? () => backend.cancel(job.request) : undefined}
               />
             ))}
           </ul>
@@ -235,7 +262,8 @@ function AgentRow({
   error: string | null;
   onInstall: () => void;
   onRemove: () => void;
-  onCancel: () => void;
+  /** Absent for an install this page did not start (stop it from the background tasks). */
+  onCancel?: () => void;
 }) {
   const actions = rowActions(agent);
   const titleId = `agent-${agent.id}`;
@@ -274,9 +302,11 @@ function AgentRow({
       </div>
       <div className={styles.actions}>
         {job ? (
-          <Button size="small" onClick={onCancel}>
-            Cancel
-          </Button>
+          onCancel && (
+            <Button size="small" onClick={onCancel}>
+              Cancel
+            </Button>
+          )
         ) : (
           <>
             {actions.install && (
diff --git a/src/features/agents/Composer.module.css b/src/features/agents/Composer.module.css
index e6f095e35..62f1c1e21 100644
--- a/src/features/agents/Composer.module.css
+++ b/src/features/agents/Composer.module.css
@@ -94,6 +94,146 @@
   color: var(--fg-muted);
   overflow-wrap: anywhere;
 }
+/* A ghost button showing a value and its detail, like a ghost Select. */
+.chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  height: var(--h-control);
+  min-width: 0;
+  padding: 0 4px 0 6px;
+  border-radius: var(--radius-control);
+  color: var(--fg-secondary);
+  white-space: nowrap;
+  transition: background var(--dur-fast) var(--ease);
+}
+.chip:hover,
+.chip[aria-expanded="true"] {
+  background: var(--bg-toolbar-hover);
+  color: var(--fg-strong);
+}
+.chipValue {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.chipDetail {
+  display: inline-grid;
+  color: var(--fg-subtle);
+}
+.chipDetail > span {
+  grid-area: 1 / 1;
+}
+.chipSizer {
+  visibility: hidden;
+}
+.chipChevron {
+  flex: none;
+  color: var(--fg-muted);
+}
+.modelEffortPopup {
+  width: min(300px, calc(100vw - 24px));
+  padding: 4px 12px 12px;
+}
+.effortHeader {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 12px;
+  margin-top: 12px;
+}
+.effortValue {
+  color: var(--fg-strong);
+}
+.effortSlider {
+  --thumb: 14px;
+  margin-top: 8px;
+}
+.effortSlider input {
+  display: block;
+  width: 100%;
+  height: var(--thumb);
+  margin: 0;
+  appearance: none;
+  background: transparent;
+}
+.effortSlider input::-webkit-slider-runnable-track {
+  height: 4px;
+  border-radius: 2px;
+  background: linear-gradient(to right, var(--accent) var(--fill), var(--control-off) var(--fill));
+}
+.effortSlider input::-webkit-slider-thumb {
+  width: var(--thumb);
+  height: var(--thumb);
+  margin-top: calc((4px - var(--thumb)) / 2);
+  border-radius: 50%;
+  appearance: none;
+  background: var(--fg-on-accent);
+  box-shadow:
+    0 0 0 1px var(--border-button),
+    var(--shadow-tooltip);
+}
+.effortSlider input:focus-visible {
+  outline: none;
+}
+.effortSlider input:focus-visible::-webkit-slider-thumb {
+  box-shadow: 0 0 0 2px var(--focus-ring);
+}
+/* One dot per level, centred under the thumb's positions. */
+.effortTicks {
+  display: flex;
+  justify-content: space-between;
+  padding: 0 calc(var(--thumb) / 2 - 2px);
+  margin-top: 4px;
+}
+.effortTicks > span {
+  width: 4px;
+  height: 4px;
+  border-radius: 50%;
+  background: var(--control-off);
+}
+.effortTicks > .effortTickActive {
+  background: var(--accent);
+}
+.modePopup {
+  min-width: 200px;
+  padding: 6px 0;
+}
+.modeList {
+  display: flex;
+  flex-direction: column;
+}
+.modeOption {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  height: 24px;
+  margin: 0 6px;
+  padding: 0 8px;
+  border-radius: var(--radius-row);
+  color: var(--fg-strong);
+  text-align: left;
+  white-space: nowrap;
+}
+.modeOption:hover,
+.modeOption:focus-visible {
+  outline: none;
+  background: var(--bg-list-selected);
+}
+.modeCheck {
+  width: 12px;
+  flex: none;
+  color: var(--fg-muted);
+}
+.modeFooter {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  margin-top: 6px;
+  padding: 8px 14px 2px;
+  border-top: 1px solid var(--border);
+}
 @container agent-composer (max-width: 600px) {
   .bar {
     flex-direction: column;
diff --git a/src/features/agents/ConfigPickers.test.tsx b/src/features/agents/ConfigPickers.test.tsx
index e0c0a828c..d2a347924 100644
--- a/src/features/agents/ConfigPickers.test.tsx
+++ b/src/features/agents/ConfigPickers.test.tsx
@@ -78,6 +78,63 @@ it("shows Cursor approvals separately from its execution mode and sends the choi
   expect(onChange).toHaveBeenCalledWith("openidea.cursor.approval", "bypass");
 });
 
+it("shows Allow All as a switch and sends on/off values", () => {
+  const onChange = vi.fn();
+  render(
+    <ConfigPickers
+      config={[
+        {
+          id: "allow_all",
+          name: "Allow All",
+          category: "permissions",
+          description: null,
+          current: "off",
+          via: "option",
+          values: [value("on", "On"), value("off", "Off")],
+        },
+      ]}
+      onChange={onChange}
+    />,
+  );
+  fireEvent.click(screen.getByRole("switch", { name: "Allow All" }));
+  expect(onChange).toHaveBeenCalledExactlyOnceWith("allow_all", "on");
+});
+
+it("shows Allow All inside the mode popup when both options exist", () => {
+  const onChange = vi.fn();
+  render(
+    <ConfigPickers
+      config={[
+        {
+          id: "mode",
+          name: "Mode",
+          category: "mode",
+          description: null,
+          current: "agent",
+          via: "option",
+          values: [value("agent", "Agent"), value("plan", "Plan"), value("autopilot", "Autopilot")],
+        },
+        {
+          id: "allow_all",
+          name: "Allow All",
+          category: "permissions",
+          description: null,
+          current: "off",
+          via: "option",
+          values: [value("on", "On"), value("off", "Off")],
+        },
+      ]}
+      onChange={onChange}
+    />,
+  );
+  fireEvent.click(screen.getByRole("button", { name: "Mode" }));
+  fireEvent.click(screen.getByRole("option", { name: "Plan" }));
+  expect(onChange).toHaveBeenNthCalledWith(1, "mode", "plan");
+  fireEvent.click(screen.getByRole("button", { name: "Mode" }));
+  fireEvent.click(screen.getByRole("switch", { name: "Allow All" }));
+  expect(onChange).toHaveBeenNthCalledWith(2, "allow_all", "on");
+});
+
 it("sends the complete nested model id through ConfigPickers", () => {
   const onChange = vi.fn();
   render(<ConfigPickers config={[config([value("9router/cmc/Beam")])]} onChange={onChange} />);
@@ -110,3 +167,80 @@ it("edits secondary settings from the compact popup and restores focus when dism
   expect(screen.queryByRole("dialog", { name: "Agent settings" })).not.toBeInTheDocument();
   expect(trigger).toHaveFocus();
 });
+
+describe("model and effort button", () => {
+  const copilotConfig = (effortLevels: string[] | null = ["low", "medium", "high", "xhigh"]): AgentConfigOption[] => [
+    {
+      id: "model",
+      name: "Model",
+      category: "model",
+      description: null,
+      current: "claude-sonnet-5.5",
+      via: "option",
+      values: [value("claude-sonnet-5.5", "Claude Sonnet 5.5", "1x"), value("gpt-6-sol", "GPT-6 Sol", "1x")],
+    },
+    ...(effortLevels
+      ? [
+          {
+            id: "reasoning_effort",
+            name: "Reasoning Effort",
+            category: "thought_level",
+            description: null,
+            current: "medium",
+            via: "option" as const,
+            values: effortLevels.map((lvl) => value(lvl, lvl === "xhigh" ? "XHigh" : lvl)),
+          },
+        ]
+      : []),
+    {
+      id: "mode",
+      name: "Mode",
+      category: "mode",
+      description: null,
+      current: "https://agentclientprotocol.com/protocol/session-modes#agent",
+      via: "option",
+      values: [
+        value("https://agentclientprotocol.com/protocol/session-modes#agent", "Agent"),
+        value("https://agentclientprotocol.com/protocol/session-modes#plan", "Plan"),
+      ],
+    },
+    {
+      id: "allow_all",
+      name: "Allow All",
+      category: "permissions",
+      description: null,
+      current: "on",
+      via: "option",
+      values: [value("on", "On"), value("off", "Off")],
+    },
+  ];
+
+  it("shows the model with the agent's effort name and the mode with Allow All", () => {
+    render(<ConfigPickers config={copilotConfig()} onChange={vi.fn()} />);
+    const model = screen.getByRole("button", { name: "Model" });
+    expect(model).toHaveTextContent("Claude Sonnet 5.5medium");
+    expect(screen.getByRole("button", { name: "Mode" })).toHaveTextContent("AgentAllow All");
+    expect(screen.queryByRole("button", { name: "Reasoning Effort" })).not.toBeInTheDocument();
+  });
+
+  it("steps through the advertised effort levels and picks a model from the popup", () => {
+    const onChange = vi.fn();
+    render(<ConfigPickers config={copilotConfig()} values={{ reasoning_effort: "high" }} onChange={onChange} />);
+    fireEvent.click(screen.getByRole("button", { name: "Model" }));
+    const dialog = screen.getByRole("dialog", { name: "Model & effort settings" });
+    const slider = within(dialog).getByRole("slider", { name: "Reasoning Effort" });
+    expect(slider).toHaveAttribute("max", "3");
+    expect(slider).toHaveValue("2");
+    expect(slider).toHaveAttribute("aria-valuetext", "high");
+    fireEvent.change(slider, { target: { value: "3" } });
+    expect(onChange).toHaveBeenLastCalledWith("reasoning_effort", "xhigh");
+    fireEvent.click(within(dialog).getByRole("button", { name: "Model" }));
+    fireEvent.click(screen.getByRole("option", { name: /GPT-6 Sol/ }));
+    expect(onChange).toHaveBeenLastCalledWith("model", "gpt-6-sol");
+  });
+
+  it("keeps a plain model picker when the agent has no effort option", () => {
+    render(<ConfigPickers config={copilotConfig(null)} onChange={vi.fn()} />);
+    expect(screen.getByRole("button", { name: "Model" })).toHaveAttribute("aria-haspopup", "listbox");
+  });
+});
diff --git a/src/features/agents/ConfigPickers.tsx b/src/features/agents/ConfigPickers.tsx
index dbb6f2331..9118b2202 100644
--- a/src/features/agents/ConfigPickers.tsx
+++ b/src/features/agents/ConfigPickers.tsx
@@ -1,12 +1,14 @@
 /**
- * Model, mode, approvals and thinking-effort dropdowns for a composer's bottom row.
- * Modes and approvals use icons; levels are plain text.
+ * Model, mode, approvals and thinking-effort controls for a composer's bottom row.
+ * With both a model and an effort option, one button shows both and opens the model
+ * list and an effort slider; with a mode and an on/off permissions option (Allow All),
+ * the mode menu carries the switch. Names and descriptions are the agent's own.
  */
-import { useRef, useState } from "react";
+import { useRef, useState, type CSSProperties } from "react";
 import clsx from "clsx";
 import type { AgentConfigOption } from "@/bindings";
 import { useTx } from "@/platform/i18n";
-import { IconButton, Popup, Select, T } from "@/ui";
+import { Icon, IconButton, Popup, Select, T, Toggle } from "@/ui";
 import type { SelectOption } from "@/ui/Select";
 import { mainOptions, modeIcon } from "./composerModel";
 import styles from "./Composer.module.css";
@@ -34,6 +36,17 @@ export function configPickerOptions(option: AgentConfigOption): SelectOption[] {
   ];
 }
 
+/** The on and off values of a two-state permissions option, or null when it has other values. */
+function switchValues(option: AgentConfigOption): { on: string; off: string } | null {
+  if (option.category !== "permissions") return null;
+  const on = option.values.find((v) => /^(on|true)$/i.test(v.value))?.value;
+  const off = option.values.find((v) => /^(off|false)$/i.test(v.value))?.value;
+  return on && off ? { on, off } : null;
+}
+
+const selected = (option: AgentConfigOption, value: string | null) =>
+  option.values.find((v) => v.value === value) ?? null;
+
 export function ConfigPickers({
   config,
   values,
@@ -48,26 +61,46 @@ export function ConfigPickers({
   const [open, setOpen] = useState(false);
   const anchor = useRef<HTMLButtonElement>(null);
   const options = mainOptions(config);
-  const secondary = options.filter((o) => o.category !== "model");
+  const valueOf = (o: AgentConfigOption) => values?.[o.id] ?? o.current ?? null;
+  const model = options.find((o) => o.category === "model");
+  const effort = model && options.find((o) => o.category === "thought_level" && o.values.length > 0);
+  const mode = options.find((o) => o.category === "mode");
+  const allowAll = mode && options.find((o) => switchValues(o));
+  const inline = options.filter((o) => o !== effort && o !== allowAll);
+  // The compact menu holds everything but the model button (which carries the effort).
+  const secondary = options.filter((o) => o.category !== "model" && o !== effort);
   const approval = secondary.find((o) => o.category === "approval" || o.category === "mode");
-  const summary = secondary
-    .map((o) => {
-      const value = values?.[o.id] ?? o.current;
-      return `${tx(o.name)}: ${o.values.find((v) => v.value === value)?.name ?? tx("Default")}`;
-    })
-    .join(" · ");
+  const summary = secondary.map((o) => `${tx(o.name)}: ${selected(o, valueOf(o))?.name ?? tx("Default")}`).join(" · ");
   return (
     <>
-      {options.map((o) => (
+      {inline.map((o) => (
         <span key={o.id} className={clsx(styles.configPicker, o.category !== "model" && styles.inlineSetting)}>
-          <ConfigPicker option={o} value={values?.[o.id] ?? o.current ?? null} onChange={onChange} />
+          {o === model && effort ? (
+            <ModelEffortPicker
+              model={o}
+              modelValue={valueOf(o)}
+              effort={effort}
+              effortValue={valueOf(effort)}
+              onChange={onChange}
+            />
+          ) : o === mode && allowAll ? (
+            <ModePicker
+              mode={o}
+              modeValue={valueOf(o)}
+              allowAll={allowAll}
+              allowAllValue={valueOf(allowAll)}
+              onChange={onChange}
+            />
+          ) : (
+            <ConfigPicker option={o} value={valueOf(o)} onChange={onChange} />
+          )}
         </span>
       ))}
       {secondary.length > 0 && (
         <div className={styles.settingsMenu}>
           <IconButton
             ref={anchor}
-            icon={approval ? modeIcon(values?.[approval.id] ?? approval.current ?? "") : "settings"}
+            icon={approval ? modeIcon(valueOf(approval) ?? "") : "settings"}
             title={`${tx("Agent settings")}: ${summary}`}
             aria-label={tx("Agent settings")}
             aria-haspopup="dialog"
@@ -88,7 +121,7 @@ export function ConfigPickers({
             {secondary.map((o) => (
               <div key={o.id} className={styles.settingsRow}>
                 <span className={styles.settingsLabel}>{tx(o.name)}</span>
-                <ConfigPicker option={o} value={values?.[o.id] ?? o.current ?? null} onChange={onChange} framed />
+                <ConfigPicker option={o} value={valueOf(o)} onChange={onChange} framed />
               </div>
             ))}
           </Popup>
@@ -110,6 +143,17 @@ function ConfigPicker({
   framed?: boolean;
 }) {
   const tx = useTx();
+  const toggle = switchValues(option);
+  if (toggle) {
+    return (
+      <Toggle
+        checked={value === toggle.on}
+        aria-label={tx(option.name)}
+        label={framed ? undefined : tx(option.name)}
+        onChange={(checked) => onChange(option.id, checked ? toggle.on : toggle.off)}
+      />
+    );
+  }
   return (
     <Select
       variant={framed ? "framed" : "ghost"}
@@ -142,3 +186,193 @@ function ConfigPicker({
     />
   );
 }
+
+/** One button for the model and its effort; the popup has the model list and an effort slider. */
+function ModelEffortPicker({
+  model,
+  modelValue,
+  effort,
+  effortValue,
+  onChange,
+}: {
+  model: AgentConfigOption;
+  modelValue: string | null;
+  effort: AgentConfigOption;
+  effortValue: string | null;
+  onChange: (option: string, value: string) => void;
+}) {
+  const tx = useTx();
+  const [open, setOpen] = useState(false);
+  const anchor = useRef<HTMLButtonElement>(null);
+  const modelName = selected(model, modelValue)?.name ?? tx("Default");
+  const effortName = selected(effort, effortValue)?.name ?? tx("Default");
+  const summary = `${tx(model.name)}: ${modelName} · ${tx(effort.name)}: ${effortName}`;
+  return (
+    <>
+      <button
+        ref={anchor}
+        type="button"
+        className={styles.chip}
+        aria-label={tx(model.name)}
+        aria-haspopup="dialog"
+        aria-expanded={open}
+        title={summary}
+        onClick={() => setOpen((v) => !v)}
+      >
+        <span className={styles.chipValue}>{modelName}</span>
+        {/* Every level's name in one cell, so the button keeps the widest one's width. */}
+        <span className={styles.chipDetail}>
+          {[...new Set([effortName, ...effort.values.map((v) => v.name)])].map((name) => (
+            <span
+              key={name}
+              className={name === effortName ? undefined : styles.chipSizer}
+              aria-hidden={name !== effortName}
+            >
+              {name}
+            </span>
+          ))}
+        </span>
+        <Icon name="chevron-down" size={14} className={styles.chipChevron} />
+      </button>
+      <Popup
+        open={open}
+        anchor={anchor}
+        onClose={() => setOpen(false)}
+        aria-label={tx("Model & effort settings")}
+        className={styles.modelEffortPopup}
+      >
+        <div className={styles.settingsRow}>
+          <span className={styles.settingsLabel}>{tx(model.name)}</span>
+          <ConfigPicker option={model} value={modelValue} onChange={onChange} framed />
+        </div>
+        <div className={styles.effortHeader}>
+          <span className={styles.settingsLabel}>{tx(effort.name)}</span>
+          <span className={styles.effortValue}>{effortName}</span>
+        </div>
+        <EffortSlider option={effort} value={effortValue} onChange={(v) => onChange(effort.id, v)} />
+      </Popup>
+    </>
+  );
+}
+
+/** A stepped slider over the agent's effort levels, in the order the agent lists them. */
+function EffortSlider({
+  option,
+  value,
+  onChange,
+}: {
+  option: AgentConfigOption;
+  value: string | null;
+  onChange: (value: string) => void;
+}) {
+  const tx = useTx();
+  const steps = option.values;
+  const index = Math.max(
+    0,
+    steps.findIndex((v) => v.value === value),
+  );
+  const last = steps.length - 1;
+  const fill = last > 0 ? (index / last) * 100 : 100;
+  return (
+    <div className={styles.effortSlider}>
+      <input
+        type="range"
+        min={0}
+        max={last}
+        step={1}
+        value={index}
+        aria-label={tx(option.name)}
+        aria-valuetext={steps[index]?.name}
+        title={steps[index]?.description ?? undefined}
+        style={{ "--fill": `${fill}%` } as CSSProperties}
+        onChange={(e) => {
+          const next = steps[Number(e.target.value)];
+          if (next && next.value !== value) onChange(next.value);
+        }}
+      />
+      <div className={styles.effortTicks} aria-hidden>
+        {steps.map((v) => (
+          <span key={v.value} className={clsx(v.value === steps[index]?.value && styles.effortTickActive)} />
+        ))}
+      </div>
+    </div>
+  );
+}
+
+/** The mode menu, with the agent's on/off permissions option (Allow All) as a switch under it. */
+function ModePicker({
+  mode,
+  modeValue,
+  allowAll,
+  allowAllValue,
+  onChange,
+}: {
+  mode: AgentConfigOption;
+  modeValue: string | null;
+  allowAll: AgentConfigOption;
+  allowAllValue: string | null;
+  onChange: (option: string, value: string) => void;
+}) {
+  const tx = useTx();
+  const [open, setOpen] = useState(false);
+  const anchor = useRef<HTMLButtonElement>(null);
+  const toggle = switchValues(allowAll)!;
+  const current = selected(mode, modeValue);
+  const on = allowAllValue === toggle.on;
+  const summary = `${tx(mode.name)}: ${current?.name ?? tx("Default")} · ${tx(allowAll.name)}: ${on ? tx("On") : tx("Off")}`;
+  return (
+    <>
+      <button
+        ref={anchor}
+        type="button"
+        className={styles.chip}
+        aria-label={tx(mode.name)}
+        aria-haspopup="dialog"
+        aria-expanded={open}
+        title={summary}
+        onClick={() => setOpen((v) => !v)}
+      >
+        <Icon name={on ? "unlock" : modeIcon(current?.value ?? "")} size={14} />
+        <span className={styles.chipValue}>{current?.name ?? tx("Default")}</span>
+        {on && <span className={styles.chipDetail}>{tx(allowAll.name)}</span>}
+        <Icon name="chevron-down" size={14} className={styles.chipChevron} />
+      </button>
+      <Popup
+        open={open}
+        anchor={anchor}
+        onClose={() => setOpen(false)}
+        aria-label={tx(mode.name)}
+        className={styles.modePopup}
+      >
+        <div role="listbox" aria-label={tx(mode.name)} className={styles.modeList}>
+          {mode.values.map((v) => (
+            <button
+              key={v.value}
+              type="button"
+              role="option"
+              aria-selected={v.value === current?.value}
+              title={v.description ?? undefined}
+              className={styles.modeOption}
+              onClick={() => {
+                onChange(mode.id, v.value);
+                setOpen(false);
+              }}
+            >
+              <span className={styles.modeCheck}>{v.value === current?.value && <Icon name="check" size={12} />}</span>
+              <Icon name={modeIcon(v.value)} size={14} />
+              <span className={styles.chipValue}>{v.name}</span>
+            </button>
+          ))}
+        </div>
+        <div className={styles.modeFooter}>
+          <span title={allowAll.description ?? undefined}>{tx(allowAll.name)}</span>
+          <Toggle
+            checked={on}
+            aria-label={tx(allowAll.name)}
+            onChange={(checked) => onChange(allowAll.id, checked ? toggle.on : toggle.off)}
+          />
+        </div>
+      </Popup>
+    </>
+  );
+}
diff --git a/src/features/agents/Markdown.tsx b/src/features/agents/Markdown.tsx
index a0da3f508..6ba05f6e1 100644
--- a/src/features/agents/Markdown.tsx
+++ b/src/features/agents/Markdown.tsx
@@ -17,7 +17,21 @@ import styles from "./Session.module.css";
 
 const marked = new Marked({ gfm: true, breaks: true });
 
+/** Rendered messages by text, least recently used first: reopening a conversation renders it again. */
+const rendered = new Map<string, string>();
+const RENDERED_MAX = 500;
+
 export function markdownHtml(text: string): string {
+  let html = rendered.get(text);
+  if (html === undefined) {
+    html = renderHtml(text);
+    if (rendered.size >= RENDERED_MAX) rendered.delete(rendered.keys().next().value!);
+  } else rendered.delete(text);
+  rendered.set(text, html);
+  return html;
+}
+
+function renderHtml(text: string): string {
   const html = marked.parse(text, { async: false }) as string;
   // Replies can quote repository content. Styles would reach the whole IDE, and the click
   // handlers below trust `data-copy` / `data-path`, which only `enhance` may set.
diff --git a/src/features/agents/Session.module.css b/src/features/agents/Session.module.css
index d1a7e8017..067297bc0 100644
--- a/src/features/agents/Session.module.css
+++ b/src/features/agents/Session.module.css
@@ -46,9 +46,14 @@
   border-bottom: 1px solid var(--border);
   flex: none;
   min-width: 0;
+  overflow: hidden;
 }
+.header > * {
+  flex: none;
+}
+/* Shrinks ahead of the meters. */
 .title {
-  flex: 0 1 auto;
+  flex: 0 1000 auto;
   min-width: 0;
   font-weight: 600;
   color: var(--fg-strong);
@@ -539,11 +544,17 @@
   white-space: nowrap;
 }
 
+/* Meters that don't fit wrap onto a hidden second row instead of being cut in half. */
 .meters {
-  flex: none;
+  flex: 0 1 auto;
+  min-width: 0;
+  height: 22px;
+  overflow: hidden;
   display: inline-flex;
+  flex-wrap: wrap;
   align-items: center;
-  gap: 10px;
+  align-content: flex-start;
+  gap: 0 10px;
   color: var(--fg-subtle);
   font-size: var(--fs-small);
   font-variant-numeric: tabular-nums;
@@ -552,6 +563,7 @@
 .meter {
   display: inline-flex;
   align-items: center;
+  height: 22px;
   gap: 5px;
 }
 .usageBar {
diff --git a/src/features/agents/SessionEditor.tsx b/src/features/agents/SessionEditor.tsx
index b74a2b4cc..f1c777a13 100644
--- a/src/features/agents/SessionEditor.tsx
+++ b/src/features/agents/SessionEditor.tsx
@@ -1,5 +1,14 @@
 /** An agent task as an editor tab: the conversation, a composer and the task's changed files. */
-import { Fragment, useEffect, useLayoutEffect, useMemo, useRef, useState, type RefObject } from "react";
+import {
+  Fragment,
+  startTransition,
+  useEffect,
+  useLayoutEffect,
+  useMemo,
+  useRef,
+  useState,
+  type RefObject,
+} from "react";
 import clsx from "clsx";
 import { useShallow } from "zustand/react/shallow";
 import type { AgentChange, AgentEntry, AgentImage, AgentLimit, AgentRetry, AgentTask, AgentUsage } from "@/bindings";
@@ -92,14 +101,17 @@ function TaskSession({ id, docked }: { id: string; docked: boolean }) {
     useShallow((s) => path.map((sub, i) => findSubagent(s.entries.get(entriesKey(id, path[i - 1] ?? null)), sub))),
   );
   useEffect(() => {
-    void loadEntries(id).catch(() => undefined);
+    // Loaded entries are kept current by the task's events: reopening the tab needn't fetch them again.
+    if (!useAgents.getState().entries.has(id)) void loadEntries(id).catch(() => undefined);
     void refreshChanges(id);
   }, [id]);
   useEffect(() => {
     if (!docked || !changesOpen) return markVisible(id);
   }, [id, docked, changesOpen]);
   useEffect(() => {
-    if (view) void loadEntries(id, view).catch(() => undefined);
+    if (view && !useAgents.getState().entries.has(entriesKey(id, view))) {
+      void loadEntries(id, view).catch(() => undefined);
+    }
   }, [id, view]);
   const openSubagent = (sub: string) => setPath((p) => [...p, sub]);
   const [finding, setFinding] = useState(false);
@@ -412,6 +424,9 @@ interface StreamProps {
   onCloseFind: () => void;
 }
 
+/** Entries rendered at a time when a conversation opens at its end. */
+const ENTRY_BATCH = 40;
+
 function Stream({ task, entries, subagent, onOpenSubagent, finding, findFocus, onCloseFind }: StreamProps) {
   const ref = useRef<HTMLDivElement>(null);
   useSelectionBoundary(ref);
@@ -419,6 +434,13 @@ function Stream({ task, entries, subagent, onOpenSubagent, finding, findFocus, o
   const positions = useAgents.getState().scrollPositions;
   const position = useRef(positions.get(key) ?? { top: 0, stick: true });
   const restored = useRef(false);
+  // Opened at the end, the last entries come first and the earlier ones follow in batches:
+  // reopening a long conversation paints at once. A kept offset needs them all.
+  const [shown, setShown] = useState(() => (positions.get(key)?.stick === false ? Infinity : ENTRY_BATCH));
+  const start = finding || !entries ? 0 : Math.max(0, entries.length - shown);
+  useEffect(() => {
+    if (start > 0) startTransition(() => setShown((n) => n + ENTRY_BATCH));
+  }, [start]);
   useLayoutEffect(() => {
     const el = ref.current;
     if (!el || entries === null) return;
@@ -470,16 +492,18 @@ function Stream({ task, entries, subagent, onOpenSubagent, finding, findFocus, o
         {entries === null ? (
           <Spinner />
         ) : (
-          entries.map((entry, i) => (
-            <Entry
-              key={i}
-              task={task}
-              entry={entry}
-              turn={turns?.get(i) ?? null}
-              turnCount={turns?.size ?? 0}
-              onOpenSubagent={onOpenSubagent}
-            />
-          ))
+          entries
+            .slice(start)
+            .map((entry, i) => (
+              <Entry
+                key={start + i}
+                task={task}
+                entry={entry}
+                turn={turns?.get(start + i) ?? null}
+                turnCount={turns?.size ?? 0}
+                onOpenSubagent={onOpenSubagent}
+              />
+            ))
         )}
         {subagent && subagentWorking(subagent.status) && (
           <div className={styles.working}>
@@ -1271,11 +1295,7 @@ function SessionComposer({
         toolbar={<ConfigPickers config={task.config} onChange={setOption} />}
         actions={
           <>
-            {busy && (
-              <Button size="small" icon="stop" onClick={() => void cancelTask(task.id)}>
-                Stop
-              </Button>
-            )}
+            {busy && <IconButton icon="stop" title="Stop" size="small" onClick={() => void cancelTask(task.id)} />}
             <SubmitButton
               label={busy ? "Queue" : "Send"}
               pending={sending}
diff --git a/src/features/agents/agentRegistry.test.tsx b/src/features/agents/agentRegistry.test.tsx
index 76aadae1a..734cc6217 100644
--- a/src/features/agents/agentRegistry.test.tsx
+++ b/src/features/agents/agentRegistry.test.tsx
@@ -42,6 +42,7 @@ const agent = (partial: Partial<RegistryAgent> & Pick<RegistryAgent, "id" | "nam
   noChecksum: false,
   installed: null,
   update: false,
+  installing: false,
   ...partial,
 });
 
@@ -67,14 +68,16 @@ const AGENTS: RegistryAgent[] = [AMP, CLINE, FAST];
 class FakeBackend implements RegistryBackend {
   registry: AgentRegistry = { agents: AGENTS, warning: null };
   installs: string[] = [];
+  installRequests: RequestId[] = [];
   removed: string[] = [];
   cancelled: RequestId[] = [];
   finish: () => void = () => {};
   fail: (e: unknown) => void = () => {};
   emit: (e: InstallEvent) => void = () => {};
   list = vi.fn(async () => this.registry);
-  install(id: string, _request: RequestId, onEvent: (e: InstallEvent) => void) {
+  install(id: string, request: RequestId, onEvent: (e: InstallEvent) => void) {
     this.installs.push(id);
+    this.installRequests.push(request);
     this.emit = onEvent;
     return new Promise<void>((resolve, reject) => {
       this.finish = resolve;
@@ -267,7 +270,7 @@ describe("Agents settings page", () => {
     expect(screen.queryByRole("dialog")).toBeNull();
   });
 
-  it("shows why an install failed, and cancels one when the page closes", async () => {
+  it("shows why an install failed, cancels one on Cancel, and leaves it running when the page closes", async () => {
     const backend = new FakeBackend();
     const { unmount } = renderRegistry(<AgentRegistryPage backend={backend} />);
     await waitFor(() => expect(row("Cline")).toBeInTheDocument());
@@ -278,10 +281,34 @@ describe("Agents settings page", () => {
     fireEvent.click(within(row("Amp")).getByRole("button", { name: "Install" }));
     fireEvent.click(within(row("Amp")).getByRole("button", { name: "Cancel" }));
     expect(backend.cancelled).toHaveLength(1);
-    // Leaving the page stops an install still running.
-    const install = backend.cancelled[0];
+    const cancelled = backend.cancelled[0];
+    await act(async () => backend.fail(new IpcError({ kind: "cancelled", message: "cancelled" })));
+
+    // An install keeps going after the page closes (it is a background task then).
+    fireEvent.click(within(row("Amp")).getByRole("button", { name: "Install" }));
+    const running = backend.installRequests.at(-1);
     unmount();
-    expect(backend.cancelled.filter((r) => r === install)).toHaveLength(2);
+    expect(backend.cancelled).not.toContain(running);
+    expect(backend.cancelled.filter((r) => r === cancelled)).toHaveLength(1);
+  });
+
+  it("follows an install started before the page opened until it ends", async () => {
+    const backend = new FakeBackend();
+    const onChanged = vi.fn();
+    backend.registry = { agents: [{ ...AMP, installing: true }, CLINE], warning: null };
+    renderRegistry(<AgentRegistryPage onChanged={onChanged} backend={backend} />);
+    await waitFor(() => expect(row("Amp")).toBeInTheDocument());
+    expect(within(row("Amp")).getByText("Installing Amp in the background…")).toBeInTheDocument();
+    // It is stopped from the background tasks, and nothing else starts meanwhile.
+    for (const name of ["Cancel", "Install", "Remove"]) {
+      expect(within(row("Amp")).queryByRole("button", { name })).toBeNull();
+    }
+    expect(within(row("Cline")).getByRole("button", { name: "Update" })).toBeDisabled();
+
+    backend.registry = { agents: [{ ...AMP, installed: AMP.version }, CLINE], warning: null };
+    await waitFor(() => expect(within(row("Amp")).getByText("Installed")).toBeInTheDocument(), { timeout: 4000 });
+    expect(onChanged).toHaveBeenCalledTimes(1);
+    expect(within(row("Cline")).getByRole("button", { name: "Update" })).toBeEnabled();
   });
 
   it("removes an installed agent", async () => {
diff --git a/src/features/agents/agents.test.ts b/src/features/agents/agents.test.ts
index 57a66e7b6..d23c3a11a 100644
--- a/src/features/agents/agents.test.ts
+++ b/src/features/agents/agents.test.ts
@@ -3,6 +3,7 @@ import type { AgentConfigOption, AgentEntry, AgentStatus, AgentTask } from "@/bi
 import {
   applyCompletion,
   atEdgeLine,
+  bypassDefaults,
   canSend,
   completionAt,
   isPathQuery,
@@ -157,11 +158,31 @@ describe("agent composer", () => {
     const config = [option("fast", ["on"], null), option("mode", ["ask", "code"], "code"), option("model", ["m"], "m")];
     expect(mainOptions(config).map((o) => o.id)).toEqual(["model", "mode"]);
     expect(nextValue(config[1]!)).toBe("ask");
+    const permissions = option("allow_all", ["off", "on"], "off");
+    permissions.category = "permissions";
+    expect(mainOptions([...config, permissions]).map((o) => o.id)).toEqual(["model", "mode", permissions.id]);
     const approvals = { ...option("openidea.cursor.approval", ["ask", "bypass"], "ask"), category: "approval" };
-    expect(mainOptions([...config, approvals]).map((o) => o.id)).toEqual(["model", "mode", approvals.id]);
+    expect(mainOptions([...config, permissions, approvals]).map((o) => o.id)).toEqual([
+      "model",
+      "mode",
+      permissions.id,
+      approvals.id,
+    ]);
     expect(
-      ["default", "acceptEdits", "plan", "auto", "bypassPermissions", "auto_edit", "read-only", "x"].map(modeIcon),
-    ).toEqual(["lock", "edit", "todo", "run", "unlock", "edit", "eye", "lock"]);
+      [
+        "default",
+        "acceptEdits",
+        "plan",
+        "auto",
+        "bypassPermissions",
+        "auto_edit",
+        "read-only",
+        "x",
+        "https://agentclientprotocol.com/protocol/session-modes#agent",
+        "https://agentclientprotocol.com/protocol/session-modes#autopilot",
+      ].map(modeIcon),
+    ).toEqual(["lock", "edit", "todo", "run", "unlock", "edit", "eye", "lock", "run", "run"]);
+    expect(bypassDefaults([...config, permissions])).toEqual({ allow_all: "on" });
     expect(usageLabel({ used: 24_000, size: 200_000 })).toEqual({
       short: "12%",
       detail: "24k / 200k tokens",
diff --git a/src/features/agents/composerModel.ts b/src/features/agents/composerModel.ts
index a0aafd410..dcb51e3aa 100644
--- a/src/features/agents/composerModel.ts
+++ b/src/features/agents/composerModel.ts
@@ -152,9 +152,9 @@ export function atEdgeLine(text: string, caret: number, dir: -1 | 1): boolean {
   return dir < 0 ? !text.slice(0, caret).includes("\n") : !text.slice(caret).includes("\n");
 }
 
-/** The settings shown as dropdowns: model, mode, approvals, thinking effort, in that order. */
+/** The settings shown in the composer: model, mode, permissions, approvals, effort. */
 export function mainOptions(config: readonly AgentConfigOption[]): AgentConfigOption[] {
-  const order = ["model", "mode", "approval", "thought_level"];
+  const order = ["model", "mode", "permissions", "approval", "thought_level"];
   return order.flatMap((c) => config.filter((o) => o.category === c).slice(0, 1));
 }
 
@@ -165,12 +165,17 @@ export const modeOption = (config: readonly AgentConfigOption[]) => config.find(
  * Claude `acceptEdits`, Gemini `auto_edit`, Codex `full-access`…). Unknown modes ask.
  */
 export function modeIcon(mode: string): string {
-  const m = mode.toLowerCase().replace(/[^a-z]/g, "");
+  const m =
+    mode
+      .toLowerCase()
+      .split(/[#/]/)
+      .at(-1)
+      ?.replace(/[^a-z]/g, "") ?? "";
   if (m.includes("plan") || m === "architect") return "todo";
   if (m.includes("bypass") || m === "yolo" || m.includes("fullaccess") || m === "dangerous") return "unlock";
   if (m.includes("readonly") || m === "ask" || m === "chat") return "eye";
   if (m.includes("edit") || m === "code") return "edit";
-  if (m === "auto" || m === "agent") return "run";
+  if (m === "auto" || m === "agent" || m.includes("autopilot")) return "run";
   return "lock";
 }
 
@@ -180,6 +185,9 @@ export function bypassDefaults(config: readonly AgentConfigOption[]): Record<str
   const mode = modeOption(config);
   const unlock = mode?.values.find((v) => modeIcon(v.value) === "unlock");
   if (mode && unlock) out[mode.id] = unlock.value;
+  const permissions = config.find((o) => o.category === "permissions");
+  const allowAll = permissions?.values.find((v) => /^(on|true)$/i.test(v.value));
+  if (permissions && allowAll) out[permissions.id] = allowAll.value;
   const approval = config.find((o) => o.category === "approval");
   if (approval?.values.some((v) => v.value === "bypass")) out[approval.id] = "bypass";
   return out;
diff --git a/src/features/agents/messageEditing.test.tsx b/src/features/agents/messageEditing.test.tsx
index 4542fa063..81a2096ef 100644
--- a/src/features/agents/messageEditing.test.tsx
+++ b/src/features/agents/messageEditing.test.tsx
@@ -256,14 +256,14 @@ describe("session composer submission", () => {
     expect(box).toHaveValue("");
   });
 
-  it("keeps Queue named and leaves Stop unchanged while the agent works", async () => {
+  it("keeps Queue named and shows icon-only Stop actions while the agent works", async () => {
     useAgents.setState({ tasks: new Map([[task.id, { ...task, status: "running" }]]) });
     render(<SessionEditor input={{ kind: "agent-session", key: task.id, data: { task: task.id } }} />);
     const queue = screen.getByRole("button", { name: "Queue" });
     expect(queue.textContent).toBe("");
     expect(queue).toHaveAttribute("data-tooltip", "Queue");
     expect(queue).toBeDisabled();
-    expect(screen.getAllByRole("button", { name: "Stop" }).some((button) => button.textContent === "Stop")).toBe(true);
+    expect(screen.getAllByRole("button", { name: "Stop" }).every((button) => button.textContent === "")).toBe(true);
     await screen.findByText("Original message");
   });
 });
diff --git a/src/features/agents/sessionState.test.tsx b/src/features/agents/sessionState.test.tsx
index 9d0a361f4..4a8261400 100644
--- a/src/features/agents/sessionState.test.tsx
+++ b/src/features/agents/sessionState.test.tsx
@@ -14,14 +14,16 @@ const backend = vi.hoisted(() => ({
   entries: new Map<string, AgentEntry[]>(),
   changes: [] as AgentChange[],
   answers: [] as Array<[string, number, string | null]>,
+  fetched: [] as string[],
 }));
 vi.mock("@/platform/ipc", async (original) => ({
   ...(await original<typeof import("@/platform/ipc")>()),
   commands: {
-    agentEntries: async (id: string, sub: string | null) => ({
-      status: "ok",
-      data: backend.entries.get(sub ? `${id}/${sub}` : id) ?? [],
-    }),
+    agentEntries: async (id: string, sub: string | null) => {
+      const key = sub ? `${id}/${sub}` : id;
+      backend.fetched.push(key);
+      return { status: "ok", data: backend.entries.get(key) ?? [] };
+    },
     agentChanges: async () => ({ status: "ok", data: backend.changes }),
     vcsBranchInfo: async () => ({ status: "ok", data: { head: "main" } }),
     agentRespond: async (task: string, permission: number, option: string | null) => {
@@ -177,6 +179,29 @@ describe("a pending permission request in the conversation", () => {
 });
 
 describe("session state across tasks and hosts", () => {
+  it("fetches a conversation once and shows it again from the store when its tab reopens", async () => {
+    const entries = new Map(useAgents.getState().entries);
+    entries.delete("A");
+    useAgents.setState({ entries });
+    backend.fetched = [];
+    const first = render(<SessionEditor input={input("A")} />);
+    expect(await screen.findByText("Answer A")).toBeInTheDocument();
+    first.unmount();
+    render(<SessionEditor input={input("A")} />);
+    expect(screen.getByText("Answer A")).toBeInTheDocument();
+    await act(async () => {});
+    expect(backend.fetched).toEqual(["A"]);
+  });
+
+  it("opens a long conversation at its end and renders the earlier entries after it", async () => {
+    const entries = Array.from({ length: 150 }, (_, i): AgentEntry => ({ type: "agent", text: `Reply ${i}` }));
+    useAgents.setState({ entries: new Map(useAgents.getState().entries).set("A", entries) });
+    render(<SessionEditor input={input("A")} />);
+    expect(screen.getByText("Reply 149")).toBeInTheDocument();
+    expect(await screen.findByText("Reply 0")).toBeInTheDocument();
+    expect(stream().children).toHaveLength(150);
+  });
+
   it("returns to the task conversation when the docked task changes after opening a subagent", async () => {
     const dispose = registerActions(taskActions);
     try {
diff --git a/src/features/app/__tests__/closeGuard.test.ts b/src/features/app/__tests__/closeGuard.test.ts
index 9774d8a4e..c703c1b9c 100644
--- a/src/features/app/__tests__/closeGuard.test.ts
+++ b/src/features/app/__tests__/closeGuard.test.ts
@@ -12,12 +12,22 @@ function deps(answers: PromptResult[]) {
     }),
     saveAll: vi.fn(async () => {}),
     disableConfirmExit: vi.fn(async () => {}),
+    disableConfirmTerminate: vi.fn(async () => {}),
+    runningProcesses: vi.fn(async () => []),
     onSaveFailed: vi.fn(),
   };
   return { d, asked };
 }
 
-const base: CloseInput = { quitting: false, windows: 1, confirmExit: false, dirty: 0, project: "openidea" };
+const base: CloseInput = {
+  quitting: false,
+  windows: 1,
+  confirmExit: false,
+  confirmTerminate: false,
+  processes: [],
+  dirty: 0,
+  project: "openidea",
+};
 
 describe("decideClose", () => {
   it("closes silently when nothing needs asking", async () => {
@@ -50,6 +60,46 @@ describe("decideClose", () => {
     expect(asked).toHaveLength(0);
   });
 
+  it("asks before terminating a running process", async () => {
+    const { d, asked } = deps([{ button: "terminate", checked: false }]);
+    await expect(decideClose({ ...base, confirmTerminate: true, processes: ["app"] }, d)).resolves.toBe(true);
+    expect(asked).toHaveLength(1);
+    expect(asked[0]?.title).toContain("app");
+    expect(asked[0]?.body).toContain("app");
+  });
+
+  it("names every running process in the prompt", async () => {
+    const { d, asked } = deps([{ button: "terminate", checked: false }]);
+    await expect(decideClose({ ...base, confirmTerminate: true, processes: ["app", "worker"] }, d)).resolves.toBe(true);
+    expect(asked[0]?.body).toContain("app, worker");
+  });
+
+  it("cancelling the terminate prompt keeps the window", async () => {
+    const { d } = deps([{ button: "cancel", checked: false }]);
+    await expect(decideClose({ ...base, confirmTerminate: true, processes: ["app"] }, d)).resolves.toBe(false);
+  });
+
+  it("asks about processes before discarding unsaved changes", async () => {
+    const { d, asked } = deps([{ button: "cancel", checked: false }]);
+    await expect(decideClose({ ...base, confirmTerminate: true, processes: ["app"], dirty: 1 }, d)).resolves.toBe(
+      false,
+    );
+    expect(asked).toHaveLength(1);
+    expect(d.saveAll).not.toHaveBeenCalled();
+  });
+
+  it("'don't ask again' turns process confirmation off", async () => {
+    const { d } = deps([{ button: "terminate", checked: true }]);
+    await decideClose({ ...base, confirmTerminate: true, processes: ["app"] }, d);
+    expect(d.disableConfirmTerminate).toHaveBeenCalled();
+  });
+
+  it("does not ask about processes when the setting is off", async () => {
+    const { d, asked } = deps([]);
+    await decideClose({ ...base, confirmTerminate: false, processes: ["app"] }, d);
+    expect(asked).toHaveLength(0);
+  });
+
   it("saves all on Save", async () => {
     const { d } = deps([{ button: "save", checked: false }]);
     await expect(decideClose({ ...base, dirty: 2 }, d)).resolves.toBe(true);
@@ -179,3 +229,12 @@ it("includes pending local edits and restored dirty buffers before backend dirty
     spy.mockRestore();
   }
 });
+
+it("confirmLeave asks about running processes before closing", async () => {
+  const { confirmLeave } = await import("../closeGuard");
+  const { d, asked } = deps([{ button: "cancel", checked: false }]);
+  d.runningProcesses = vi.fn(async () => ["app"]);
+  await expect(confirmLeave(d, "openidea")).resolves.toBe(false);
+  expect(asked[0]?.title).toContain("app");
+  expect(asked[0]?.body).toContain("app");
+});
diff --git a/src/features/app/__tests__/windows.test.ts b/src/features/app/__tests__/windows.test.ts
index 786cc76fe..23593f9fa 100644
--- a/src/features/app/__tests__/windows.test.ts
+++ b/src/features/app/__tests__/windows.test.ts
@@ -6,11 +6,13 @@ const projectCurrent = vi.fn();
 const windowOpenProject = vi.fn();
 const windowOpenFiles = vi.fn();
 const windowTakeLaunch = vi.fn();
+const wslResolve = vi.fn();
 const cancelClose = vi.fn();
 const notify = vi.fn();
 vi.mock("@/platform/remote", async (original) => ({
   ...(await original<typeof import("@/platform/remote")>()),
   isRemoteWindow: vi.fn(() => false),
+  connectRemote: vi.fn(async () => {}),
 }));
 // The backend answers with the global settings, here: whatever the test set up.
 const lightEditOpen = vi.fn(async (_path: string) => ({ status: "ok", data: useProject.getState().settings ?? {} }));
@@ -34,6 +36,7 @@ vi.mock("@/platform/ipc", async (orig) => {
       windowOpenProject: (...a: unknown[]) => windowOpenProject(...a),
       windowOpenFiles: (...a: unknown[]) => windowOpenFiles(...a),
       windowTakeLaunch: () => windowTakeLaunch(),
+      wslResolve: (p: string) => wslResolve(p),
       lightEditOpen: (p: string) => lightEditOpen(p),
       fsReadDir: (p: string) => fsReadDir(p),
     },
@@ -55,7 +58,7 @@ const {
 } = await import("../windows");
 const { useProject } = await import("@/platform/project");
 const { provideEditorService, provideNotificationService } = await import("@/workbench/contributions");
-const { isRemoteWindow } = await import("@/platform/remote");
+const { isRemoteWindow, connectRemote } = await import("@/platform/remote");
 const { IpcError } = await import("@/platform/ipc");
 provideNotificationService({ notify });
 
@@ -77,7 +80,9 @@ const ok = (data: unknown) => ({ status: "ok", data });
 const projectState = (root: string) => ({ project: { root, name: root, trusted: true, isGit: false, settings: {} } });
 
 beforeEach(() => {
-  for (const f of [windowOpenProject, windowOpenFiles, windowTakeLaunch]) f.mockReset();
+  for (const f of [windowOpenProject, windowOpenFiles, windowTakeLaunch, wslResolve]) f.mockReset();
+  wslResolve.mockResolvedValue(null);
+  vi.mocked(connectRemote).mockClear();
   for (const f of [lightEditOpen, fsReadDir, openProject]) f.mockClear();
   cancelClose.mockClear();
   notify.mockClear();
@@ -95,6 +100,18 @@ describe("openProjectInWindow", () => {
     expect(openProject).toHaveBeenCalledWith("/p/a");
   });
 
+  it("connects to the distribution when the folder is on the WSL share", async () => {
+    const [distro, linuxPath] = ["Debian", "/srv/app"];
+    const share = `\\\\wsl.localhost\\${distro}${linuxPath.replaceAll("/", "\\")}`;
+    const target = { kind: "wsl", distro };
+    wslResolve.mockResolvedValue({ target, path: linuxPath });
+    windowOpenProject.mockResolvedValue(ok({ kind: "current" }));
+    await openProjectInWindow(share, false);
+    expect(wslResolve).toHaveBeenCalledWith(share);
+    expect(connectRemote).toHaveBeenCalledWith(target, linuxPath);
+    expect(openProject).not.toHaveBeenCalled();
+  });
+
   it("asks for a new window when this one already has a project", async () => {
     useProject.setState(projectState("/p/b") as never);
     windowOpenProject.mockResolvedValue(ok({ kind: "opened", label: "project-1" }));
diff --git a/src/features/app/closeGuard.ts b/src/features/app/closeGuard.ts
index c08195de0..dff728230 100644
--- a/src/features/app/closeGuard.ts
+++ b/src/features/app/closeGuard.ts
@@ -3,14 +3,21 @@
  *
  * Closing a window (traffic light, Quit closing every window) runs
  * `decideClose`: confirm exit when this is the last window and
- * `general.confirmExit` is on, then Save All / Don't Save / Cancel when
- * documents have unsaved changes. Quit confirms once, then the backend closes
- * every window, each of which runs only its unsaved-changes check.
+ * `general.confirmExit` is on, then Terminate / Cancel when Run/Debug processes
+ * still run and `run.confirmTerminate` is on, then Save All / Don't Save / Cancel
+ * when documents have unsaved changes. Quit confirms once, then the backend
+ * closes every window, each of which runs its own checks.
  */
 import { commands, isTauri, onIdeEvent, type Settings } from "@/platform/ipc";
 import { t } from "@/platform/i18n";
 import { closeProject, provideLeaveProjectGuard, useProject } from "@/platform/project";
-import { maybeEditorService, notifications, type EditorCloseSession } from "@/workbench/contributions";
+import { workflowSettings } from "@/platform/workflowSettings";
+import {
+  maybeEditorService,
+  notifications,
+  runningProcesses as liveProcesses,
+  type EditorCloseSession,
+} from "@/workbench/contributions";
 import { ask, type Ask } from "@/workbench/messages";
 import { AUX_CLOSED, auxiliaryWindow, closeDocumentWindows, type AuxCloseResult } from "@/platform/auxWindow";
 
@@ -29,6 +36,9 @@ export interface CloseInput {
   quitting: boolean;
   windows: number;
   confirmExit: boolean;
+  confirmTerminate: boolean;
+  /** Running Run/Debug process names this close would terminate. */
+  processes: readonly string[];
   dirty: number;
   project: string | null;
 }
@@ -37,6 +47,9 @@ export interface CloseDeps {
   ask: Ask;
   saveAll: () => Promise<void>;
   disableConfirmExit: () => Promise<void>;
+  disableConfirmTerminate: () => Promise<void>;
+  /** Running Run/Debug process names in this window. */
+  runningProcesses: () => Promise<readonly string[]>;
   onSaveFailed: (e: unknown) => void;
   /** Stops custom document edits/execution before reading their final dirty state. */
   prepareClose?: () => Promise<EditorCloseSession | undefined>;
@@ -54,6 +67,24 @@ export async function decideClose(input: CloseInput, deps: CloseDeps): Promise<b
     if (r.button !== "exit") return false;
     if (r.checked) await deps.disableConfirmExit().catch(() => {});
   }
+  if (input.confirmTerminate && input.processes.length > 0) {
+    const names = input.processes;
+    const r = await deps.ask({
+      title:
+        names.length === 1
+          ? t("app.terminateProcesses.titleOne", { name: names[0]! })
+          : t("app.terminateProcesses.titleMany", { count: names.length }),
+      body:
+        names.length === 1
+          ? t("app.terminateProcesses.bodyOne", { name: names[0]! })
+          : t("app.terminateProcesses.bodyMany", { count: names.length, names: names.join(", ") }),
+      buttons: [{ id: "terminate", label: t("app.terminateProcesses.terminate"), primary: true }],
+      checkbox: t("app.terminateProcesses.dontAsk"),
+      icon: "warning",
+    });
+    if (r.button !== "terminate") return false;
+    if (r.checked) await deps.disableConfirmTerminate().catch(() => {});
+  }
   let session: EditorCloseSession | undefined;
   let authorized = false;
   try {
@@ -94,6 +125,11 @@ const defaultDeps: CloseDeps = {
     const r = await commands.settingsSet("global", "general.confirmExit", "false");
     if (r.status === "ok") useProject.setState({ settings: r.data });
   },
+  disableConfirmTerminate: async () => {
+    const r = await commands.settingsSet("global", "run.confirmTerminate", "false");
+    if (r.status === "ok") useProject.setState({ settings: r.data });
+  },
+  runningProcesses: async () => (await liveProcesses()).map((p) => p.name),
   onSaveFailed: (e) =>
     notifications().notify({
       level: "error",
@@ -102,6 +138,11 @@ const defaultDeps: CloseDeps = {
     }),
 };
 
+/** Process names this close would terminate; an unavailable feature list never blocks closing. */
+async function processNames(deps: CloseDeps): Promise<string[]> {
+  return [...new Set(await deps.runningProcesses().catch(() => []))].filter(Boolean);
+}
+
 let closing = false;
 
 async function onCloseRequested(deps: CloseDeps): Promise<boolean> {
@@ -120,11 +161,14 @@ async function onCloseRequested(deps: CloseDeps): Promise<boolean> {
       if (await confirmLeave(deps)) await closeProject();
       return false;
     }
+    const confirmTerminate = workflowSettings().run.confirmTerminate;
     const ok = await decideClose(
       {
         quitting: ctx.quitting,
         windows: ctx.windows,
         confirmExit: confirmExitEnabled(s.settings),
+        confirmTerminate,
+        processes: confirmTerminate ? await processNames(deps) : [],
         dirty: dirtyCount(),
         project: s.project?.name ?? null,
       },
@@ -151,15 +195,36 @@ export async function confirmLeave(
   project = useProject.getState().project?.name ?? null,
 ): Promise<boolean> {
   if (!(await closeDocumentWindows())) return false;
-  return decideClose({ quitting: false, windows: 2, confirmExit: false, dirty: dirtyCount(), project }, deps);
+  const confirmTerminate = workflowSettings().run.confirmTerminate;
+  return decideClose(
+    {
+      quitting: false,
+      windows: 2,
+      confirmExit: false,
+      confirmTerminate,
+      processes: confirmTerminate ? await processNames(deps) : [],
+      dirty: dirtyCount(),
+      project,
+    },
+    deps,
+  );
 }
 
 /** Quit: confirm once (if enabled), then let the backend close every window. */
 export async function quitApp(deps: CloseDeps = defaultDeps): Promise<void> {
   if (!isTauri()) return;
   if (confirmExitEnabled(useProject.getState().settings)) {
+    // Each window asks about its own processes as the backend closes it.
     const ok = await decideClose(
-      { quitting: false, windows: 1, confirmExit: true, dirty: 0, project: null },
+      {
+        quitting: false,
+        windows: 1,
+        confirmExit: true,
+        confirmTerminate: false,
+        processes: [],
+        dirty: 0,
+        project: null,
+      },
       { ...deps, prepareClose: undefined },
     );
     if (!ok) return;
diff --git a/src/features/app/windows.ts b/src/features/app/windows.ts
index dd183db65..051775da9 100644
--- a/src/features/app/windows.ts
+++ b/src/features/app/windows.ts
@@ -53,7 +53,10 @@ async function openHere(path: string): Promise<boolean> {
   if (!isRemoteWindow() && useProject.getState().project?.root === path) return true;
   if (!(await confirmLeaveProject())) return false;
   try {
-    await openProject(path);
+    // A folder of a WSL distro runs there, not as a network folder.
+    const wsl = await commands.wslResolve(path).catch(() => null);
+    if (wsl) await connectRemote(wsl.target, wsl.path);
+    else await openProject(path);
     return true;
   } catch (e) {
     maybeEditorService()?.cancelClose?.();
@@ -219,8 +222,8 @@ export async function consumeLaunch(): Promise<void> {
     if (await openHere(launch.project)) await openInEditor(files, positions);
   } else if (files.length) await openFilesHere(files, positions);
   else if (launch?.remote) {
-    const { sshConfig, path } = launch.remote;
-    await connectRemote(sshConfig, path).catch((e) =>
+    const { target, path } = launch.remote;
+    await connectRemote(target, path).catch((e) =>
       notifications().notify({
         level: "error",
         title: t("app.window.openFailed", { name: basename(path) }),
diff --git a/src/features/build-tools/BuildToolView.tsx b/src/features/build-tools/BuildToolView.tsx
index 3680ba411..898ebd1f1 100644
--- a/src/features/build-tools/BuildToolView.tsx
+++ b/src/features/build-tools/BuildToolView.tsx
@@ -21,6 +21,7 @@ import {
 import {
   gradleChildren,
   gradleRoots,
+  gradleProjectKey,
   gradleTaskConfig,
   isRunnable,
   mavenChildren,
@@ -56,7 +57,7 @@ export function GradleView() {
 /** The run configuration a runnable node (or several of one project) starts. */
 export function nodeConfig(
   nodes: readonly BuildNode[],
-  model: { maven?: MavenModel | null; gradle?: GradleModel | null },
+  model: { maven?: MavenModel | null; gradle?: readonly GradleModel[] },
 ) {
   const settings = useBuild.getState().settings;
   const first = nodes[0];
@@ -71,13 +72,17 @@ export function nodeConfig(
     const goals = same.map((n) => (n.kind === "phase" ? n.phase : `${n.plugin.prefix}:${n.goal}`));
     return mavenGoalConfig(first.project, goals, model.maven, settings.maven);
   }
-  if (first.kind === "task" && model.gradle) {
+  if (first.kind === "task") {
+    const build = model.gradle?.find((g) => g.dir === first.build.dir);
+    const project = build?.projects.find((p) => p.path === first.project.path);
+    if (!build || !project) return null;
     const same = nodes.filter(
-      (n): n is Extract<BuildNode, { kind: "task" }> => n.kind === "task" && n.project.path === first.project.path,
+      (n): n is Extract<BuildNode, { kind: "task" }> =>
+        n.kind === "task" && n.build.dir === first.build.dir && n.project.path === first.project.path,
     );
     return gradleTaskConfig(
-      model.gradle,
-      first.project,
+      build,
+      project,
       same.map((n) => n.task.name),
       settings.gradle,
     );
@@ -89,8 +94,9 @@ export function nodeConfig(
 function childrenOf(
   tool: BuildTool,
   maven: MavenModel | null,
-  gradle: GradleModel | null,
+  gradle: readonly GradleModel[],
   configs: readonly RunConfig[],
+  root: string,
 ) {
   const cache = new Map<string, BuildNode[] | undefined>();
   return (n: BuildNode) => {
@@ -101,7 +107,7 @@ function childrenOf(
           ? mavenChildren(n, maven, configs)
           : undefined
         : gradle
-          ? gradleChildren(n, gradle, configs)
+          ? gradleChildren(n, gradle, configs, root)
           : undefined;
     cache.set(n.key, kids);
     return kids;
@@ -110,7 +116,8 @@ function childrenOf(
 
 /** Maven `pom` / Gradle project path of the project a node belongs to. */
 function nodeProject(n: BuildNode): string | undefined {
-  if ("project" in n) return "pom" in n.project ? n.project.pom : n.project.path;
+  if ("project" in n)
+    return "pom" in n.project ? n.project.pom : "build" in n ? gradleProjectKey(n.build, n.project) : undefined;
   return undefined;
 }
 
@@ -118,9 +125,8 @@ function Toolbar({ tool, selection }: { tool: BuildTool; selection: BuildNode[]
   const syncing = useBuild((s) => !!s.syncing[tool]);
   const settings = useBuild((s) => s.settings);
   const model = useBuild((s) => s.model);
-  const runnable = selection.filter(isRunnable);
+  const config = model && nodeConfig(selection.filter(isRunnable), model);
   const runSelected = () => {
-    const config = model && nodeConfig(runnable, model);
     if (config) runConfig(config, "run");
   };
   const maven = tool === "maven";
@@ -131,14 +137,14 @@ function Toolbar({ tool, selection }: { tool: BuildTool; selection: BuildNode[]
       ) : (
         <IconButton icon="refresh" size="small" iconSize={16} action={`${tool}.reload`} />
       )}
-      {maven && <IconButton icon="plus" size="small" iconSize={16} action="maven.addProjects" />}
+      <IconButton icon="plus" size="small" iconSize={16} action={maven ? "maven.addProjects" : "gradle.linkProjects"} />
       <span className={styles.sep} />
       <IconButton
         icon="run"
         size="small"
         iconSize={16}
         title={maven ? "Run Maven Build" : "Run Gradle Task"}
-        disabled={!runnable.length}
+        disabled={!config}
         onClick={runSelected}
       />
       <IconButton
@@ -181,7 +187,8 @@ function Toolbar({ tool, selection }: { tool: BuildTool; selection: BuildNode[]
 
 function Banner({ tool }: { tool: BuildTool }) {
   const sync = useBuild((s) => s.syncing[tool]);
-  const info = useBuild((s) => (tool === "maven" ? s.model?.maven : s.model?.gradle));
+  const model = useBuild((s) => s.model);
+  const infos = tool === "maven" ? (model?.maven ? [model.maven] : []) : (model?.gradle ?? []);
   if (sync)
     return (
       <div className={styles.banner} role="status">
@@ -190,7 +197,10 @@ function Banner({ tool }: { tool: BuildTool }) {
         {sync.fraction != null && <span className={styles.bannerPct}>{Math.round(sync.fraction * 100)}%</span>}
       </div>
     );
-  if (!info) return null;
+  return infos.map((info) => <BuildBanner key={"dir" in info ? info.dir : "maven"} info={info} tool={tool} />);
+}
+
+function BuildBanner({ info, tool }: { info: MavenModel | GradleModel; tool: BuildTool }) {
   if (info.stale)
     return (
       <div className={styles.banner}>
@@ -198,7 +208,7 @@ function Banner({ tool }: { tool: BuildTool }) {
         <span className={styles.bannerText}>
           <T>Build files changed since the last reload</T>
         </span>
-        <Button size="small" variant="ghost" onClick={() => void syncTool(tool)}>
+        <Button size="small" variant="ghost" onClick={() => void syncTool(tool, "dir" in info ? info.dir : null)}>
           {tool === "maven" ? "Load Maven Changes" : "Load Gradle Changes"}
         </Button>
       </div>
@@ -260,15 +270,18 @@ function BuildToolView({ tool }: { tool: BuildTool }) {
   const root = useProject((s) => s.project?.root ?? "");
   const [selection, setSelection] = useState<BuildNode[]>([]);
   const maven = model?.maven ?? null;
-  const gradle = model?.gradle ?? null;
+  const gradle = model?.gradle;
 
   const roots = useMemo(
-    () => (tool === "maven" ? (maven ? mavenRoots(maven) : []) : gradle ? gradleRoots(gradle) : []),
+    () => (tool === "maven" ? (maven ? mavenRoots(maven) : []) : gradleRoots(gradle ?? [])),
     [tool, maven, gradle],
   );
-  const getChildren = useMemo(() => childrenOf(tool, maven, gradle, configs), [tool, maven, gradle, configs]);
+  const getChildren = useMemo(
+    () => childrenOf(tool, maven, gradle ?? [], configs, root),
+    [tool, maven, gradle, configs, root],
+  );
 
-  const hasModel = tool === "maven" ? !!maven : !!gradle;
+  const hasModel = tool === "maven" ? !!maven : !!gradle?.length;
   useEffect(() => {
     if (model && hasModel && useBuild.getState().expanded[tool].size === 0)
       setExpanded(tool, initialExpanded(tool, model));
@@ -331,12 +344,22 @@ function BuildToolView({ tool }: { tool: BuildTool }) {
         items.push({
           label: tx`Open ${file.split("/").pop()}`,
           icon: "file-gradle",
-          run: () => void editorService().openFile(`${root}/${file}`),
+          run: () => void editorService().openFile(/^(?:[A-Za-z]:[\\/]|\/)/.test(file) ? file : `${root}/${file}`),
         });
+      if (node.project.path === ":")
+        items.push({ kind: "action", action: "gradle.unlinkProjects", arg: { buildDir: node.build.dir } });
       items.push(
-        { kind: "action", action: "gradle.reload", label: "Reload All Gradle Projects" },
-        { kind: "action", action: "gradle.executeTask" },
-        { kind: "action", action: "gradle.analyzeDependencies", arg: { gradlePath: node.project.path } },
+        { kind: "action", action: "gradle.reload", label: "Reload Gradle Project", arg: { buildDir: node.build.dir } },
+        {
+          kind: "action",
+          action: "gradle.executeTask",
+          arg: { projectKey: gradleProjectKey(node.build, node.project) },
+        },
+        {
+          kind: "action",
+          action: "gradle.analyzeDependencies",
+          arg: { buildDir: node.build.dir, gradlePath: node.project.path },
+        },
       );
     }
     if (node.kind === "dependency") {
diff --git a/src/features/build-tools/DependencyAnalyzer.test.tsx b/src/features/build-tools/DependencyAnalyzer.test.tsx
index 59210be35..0cb9d1bdf 100644
--- a/src/features/build-tools/DependencyAnalyzer.test.tsx
+++ b/src/features/build-tools/DependencyAnalyzer.test.tsx
@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { act, fireEvent, render, screen } from "@testing-library/react";
+import { act, fireEvent, render, screen, waitFor } from "@testing-library/react";
 import { executeAction } from "@/platform/actions";
 import { setContext } from "@/platform/context";
 import type { BuildModel, GradleDependency, GradleModel, MavenDependency } from "@/platform/ipc";
@@ -72,7 +72,7 @@ const model: BuildModel = {
     stale: false,
     syncError: null,
   },
-  gradle: null,
+  gradle: [],
 };
 
 describe("dependency analyzer", () => {
@@ -159,7 +159,7 @@ describe("dependency analyzer for Gradle", () => {
     provideEditorService({ openInput, activePath: () => null } as unknown as EditorService);
     setContext("projectOpen", true);
     dispose = activate();
-    act(() => useBuild.setState({ root: "/g", model: { maven: null, gradle } }));
+    act(() => useBuild.setState({ root: "/g", model: { maven: null, gradle: [gradle] } }));
   });
   afterEach(() => {
     dispose();
@@ -170,13 +170,13 @@ describe("dependency analyzer for Gradle", () => {
   it("opens for a project from the action and from its build script's menus", async () => {
     await executeAction("gradle.analyzeDependencies", { gradlePath: ":app" });
     expect(openInput).toHaveBeenCalledWith(expect.objectContaining({ kind: ANALYZER_KIND }), { focus: true });
-    expect(useAnalyzer.getState().module).toBe("gradle::app");
+    expect(useAnalyzer.getState().module).toBe('gradle:["",":app"]');
     const items = menuGroupItems("projectView", { paths: ["/g/app/build.gradle.kts"] });
     expect(items).toContainEqual(
       expect.objectContaining({ action: "gradle.analyzeDependencies", arg: { path: "/g/app/build.gradle.kts" } }),
     );
     await executeAction("gradle.analyzeDependencies", { path: "/g/build.gradle" });
-    expect(useAnalyzer.getState().module).toBe("gradle::");
+    expect(useAnalyzer.getState().module).toBe('gradle:["",":"]');
     expect(menuGroupItems("editor", { paths: ["/g/other/build.gradle"] })).toEqual([]);
   });
 
@@ -187,9 +187,9 @@ describe("dependency analyzer for Gradle", () => {
       ]),
       gradleDep("com.fasterxml.jackson.core:jackson-databind:2.15.3", null),
     ]);
-    act(() => useAnalyzer.setState({ module: "gradle::app" }));
+    act(() => useAnalyzer.setState({ module: 'gradle:["",":app"]' }));
     render(<DependencyAnalyzer input={{ kind: ANALYZER_KIND, key: ANALYZER_KIND }} />);
-    expect(ipc.gradle).toHaveBeenCalledWith(":app", "runtimeClasspath", false, expect.any(Number));
+    expect(ipc.gradle).toHaveBeenCalledWith(":app", "runtimeClasspath", false, expect.any(Number), "");
     await screen.findByText("com.fasterxml.jackson.core:jackson-databind");
     fireEvent.click(screen.getByRole("checkbox", { name: "Show conflicts only" }));
     expect(screen.queryByText("org.springframework.boot:spring-boot-starter-json")).toBeNull();
@@ -203,9 +203,32 @@ describe("dependency analyzer for Gradle", () => {
     expect(screen.queryByRole("button", { name: "Jump to Source" })).toBeNull();
   });
 
+  it("routes identical project paths and report caches by linked build", async () => {
+    const builds = ["one", "two"].map((dir) => ({
+      ...gradle,
+      dir,
+      syncedAt: 1,
+      projects: gradle.projects.map((p) => ({ ...p, dir: `${dir}/${p.dir}`, buildFile: `${dir}/${p.buildFile}` })),
+    }));
+    ipc.gradle.mockResolvedValue([]);
+    act(() => {
+      useBuild.setState({ model: { maven: null, gradle: builds } });
+      useAnalyzer.setState({ module: 'gradle:["one",":app"]' });
+    });
+    render(<DependencyAnalyzer input={{ kind: ANALYZER_KIND, key: ANALYZER_KIND }} />);
+    await waitFor(() =>
+      expect(ipc.gradle).toHaveBeenCalledWith(":app", "runtimeClasspath", false, expect.any(Number), "one"),
+    );
+    act(() => useAnalyzer.setState({ module: 'gradle:["two",":app"]' }));
+    await waitFor(() =>
+      expect(ipc.gradle).toHaveBeenLastCalledWith(":app", "runtimeClasspath", false, expect.any(Number), "two"),
+    );
+    expect(ipc.gradle).toHaveBeenCalledTimes(2);
+  });
+
   it("shows why Gradle could not resolve the configuration", async () => {
     ipc.gradle.mockRejectedValue(new Error("Could not resolve all files for configuration ':app:runtimeClasspath'."));
-    act(() => useAnalyzer.setState({ module: "gradle::" }));
+    act(() => useAnalyzer.setState({ module: 'gradle:["",":"]' }));
     render(<DependencyAnalyzer input={{ kind: ANALYZER_KIND, key: ANALYZER_KIND }} />);
     expect(await screen.findByText("Cannot resolve dependencies")).toBeTruthy();
     expect(screen.getByText(/Could not resolve all files/)).toBeTruthy();
diff --git a/src/features/build-tools/DependencyAnalyzer.tsx b/src/features/build-tools/DependencyAnalyzer.tsx
index 7fb71f98e..2b48e5bf9 100644
--- a/src/features/build-tools/DependencyAnalyzer.tsx
+++ b/src/features/build-tools/DependencyAnalyzer.tsx
@@ -11,7 +11,7 @@ import {
   commands,
   isCancelled,
   nextRequestId,
-  type GradleProject,
+  type GradleModel,
   type MavenDependency,
   type MavenProject,
 } from "@/platform/ipc";
@@ -53,6 +53,7 @@ import {
   type DependencyTreeNode,
   type DependencyUsage,
 } from "./analyzer";
+import { gradleProjectKey } from "./model";
 import { syncTool, useAnalyzer, useBuild } from "./store";
 import styles from "./DependencyAnalyzer.module.css";
 
@@ -67,13 +68,13 @@ const GRADLE = "gradle:";
 const CONFIGURATIONS = ["compileClasspath", "runtimeClasspath", "testCompileClasspath", "testRuntimeClasspath"];
 
 type GradleTree = { deps: MavenDependency[] | null; error: string | null; loading: boolean };
-/** Reports already read in this session, by `root|path|configuration`: reopening the tab doesn't run Gradle again. */
+/** Reports already read in this session, by workspace, build, project and configuration: reopening the tab doesn't run Gradle again. */
 const gradleTrees = new Map<string, MavenDependency[]>();
 
 /** The `dependencies` report of `path` for `configuration`, cached; a new `generation` runs Gradle again. */
-function useGradleTree(path: string | null, configuration: string, generation: number) {
+function useGradleTree(path: string | null, buildDir: string | null, configuration: string, generation: number) {
   const root = useBuild((s) => s.root);
-  const key = path && root ? `${root}|${path}|${configuration}` : null;
+  const key = path && root ? JSON.stringify([root, buildDir, path, configuration]) : null;
   const [state, setState] = useState<GradleTree & { key: string | null }>({
     key: null,
     deps: null,
@@ -98,7 +99,7 @@ function useGradleTree(path: string | null, configuration: string, generation: n
     let done = false;
     setState({ key, deps: cached ?? null, error: null, loading: true });
     const offline = useBuild.getState().settings.gradle.offline;
-    call(commands.gradleDependencies(path, configuration, offline, request))
+    call(commands.gradleDependencies(path, configuration, offline, request, buildDir))
       .then((deps) => {
         const tree = fromGradle(deps);
         gradleTrees.set(key, tree);
@@ -115,7 +116,7 @@ function useGradleTree(path: string | null, configuration: string, generation: n
       live = false;
       if (!done) void commands.cancelRequest(request).catch(() => {});
     };
-  }, [key, path, configuration, generation]);
+  }, [key, path, buildDir, configuration, generation]);
   const current: GradleTree = state.key === key ? state : { deps: null, error: null, loading: !!key };
   const cancel = () => {
     if (running.current != null) void commands.cancelRequest(running.current).catch(() => {});
@@ -162,20 +163,22 @@ function versionLabel(d: MavenDependency) {
   return d.version ?? "";
 }
 
-function moduleOptions(maven: readonly MavenProject[], gradle: readonly GradleProject[]): SelectOption[] {
+function moduleOptions(maven: readonly MavenProject[], gradle: readonly GradleModel[]): SelectOption[] {
   return [
     ...maven
       .filter((p) => p.packaging !== "pom" || p.dependencies.length > 0)
       .map((p) => ({ value: p.pom, label: p.displayName, detail: p.pom, icon: "maven-project" })),
     // buildSrc's tasks can't be run from the build.
-    ...gradle
-      .filter((p) => p.build !== ":buildSrc")
-      .map((p) => ({
-        value: `${GRADLE}${p.path}`,
-        label: p.name,
-        detail: p.path,
-        icon: p.path === ":" ? "gradle-project" : "gradle-module",
-      })),
+    ...gradle.flatMap((build) =>
+      build.projects
+        .filter((p) => !p.build?.endsWith(":buildSrc"))
+        .map((p) => ({
+          value: gradleProjectKey(build, p),
+          label: p.name,
+          detail: `${build.dir || "."} ${p.path}`,
+          icon: p.path === ":" ? "gradle-project" : "gradle-module",
+        })),
+    ),
   ];
 }
 
@@ -332,7 +335,7 @@ function UsagesPane({
 export function DependencyAnalyzer(_props: { input: EditorInput }) {
   const tx = useTx();
   const maven = useBuild((s) => s.model?.maven ?? null);
-  const gradle = useBuild((s) => s.model?.gradle ?? null);
+  const gradle = useBuild((s) => s.model?.gradle);
   const syncing = useBuild((s) => s.syncing.maven);
   const chosen = useAnalyzer((s) => s.module);
   const [query, setQuery] = useState("");
@@ -343,13 +346,18 @@ export function DependencyAnalyzer(_props: { input: EditorInput }) {
   const [mode, setMode] = useState<Mode>("list");
   const [selectedKey, setSelectedKey] = useState<string | null>(null);
 
-  const options = useMemo(() => moduleOptions(maven?.projects ?? [], gradle?.projects ?? []), [maven, gradle]);
+  const options = useMemo(() => moduleOptions(maven?.projects ?? [], gradle ?? []), [maven, gradle]);
   const value = options.some((o) => o.value === chosen) ? chosen! : (options[0]?.value ?? null);
-  const gradlePath = value?.startsWith(GRADLE) ? value.slice(GRADLE.length) : null;
+  const selectedGradle = value?.startsWith(GRADLE)
+    ? (gradle ?? [])
+        .flatMap((build) => build.projects.map((project) => ({ build, project })))
+        .find(({ build, project }) => gradleProjectKey(build, project) === value)
+    : null;
+  const gradlePath = selectedGradle?.project.path ?? null;
   const pom = value != null && gradlePath == null ? value : null;
   const module = pom ? (maven?.projects.find((p) => p.pom === pom) ?? null) : null;
-  const gradleProject = gradlePath != null ? (gradle?.projects.find((p) => p.path === gradlePath) ?? null) : null;
-  const report = useGradleTree(gradlePath, configuration, generation);
+  const gradleProject = selectedGradle?.project ?? null;
+  const report = useGradleTree(gradlePath, selectedGradle?.build.dir ?? null, configuration, generation);
   const deps = useMemo(
     () => (gradlePath != null ? (report.deps ?? []) : (module?.dependencies ?? [])),
     [gradlePath, report.deps, module],
@@ -428,7 +436,7 @@ export function DependencyAnalyzer(_props: { input: EditorInput }) {
     showContextMenu({ x: e.clientX, y: e.clientY }, items);
   };
 
-  if (!maven && !gradle) return <EmptyState title="No Maven or Gradle projects" />;
+  if (!maven && !gradle?.length) return <EmptyState title="No Maven or Gradle projects" />;
 
   const treeView = (
     <div className={styles.body}>
diff --git a/src/features/build-tools/ExecutePopup.tsx b/src/features/build-tools/ExecutePopup.tsx
index 7327a929c..a4ac94853 100644
--- a/src/features/build-tools/ExecutePopup.tsx
+++ b/src/features/build-tools/ExecutePopup.tsx
@@ -8,7 +8,7 @@ import { useMemo, useState, type KeyboardEvent } from "react";
 import clsx from "clsx";
 import type { BuildTool } from "@/platform/ipc";
 import { HighlightedText, Input, List, Popup, Select, listNavigate, T } from "@/ui";
-import { goalCompletions, taskCompletions, type Completion } from "./model";
+import { goalCompletions, gradleProjectForKey, gradleProjectKey, taskCompletions, type Completion } from "./model";
 import { executeBuildLine } from "./runAnything";
 import { readHistory, useBuild } from "./store";
 import styles from "./BuildTools.module.css";
@@ -32,7 +32,13 @@ function ExecutePopup({ tool }: { tool: BuildTool }) {
     () =>
       tool === "maven"
         ? (maven?.projects ?? []).map((p) => ({ value: p.pom, label: p.displayName, detail: p.dir || "." }))
-        : (gradle?.projects ?? []).map((p) => ({ value: p.path, label: p.name, detail: p.path })),
+        : (gradle ?? []).flatMap((build) =>
+            build.projects.map((p) => ({
+              value: gradleProjectKey(build, p),
+              label: p.name,
+              detail: `${build.dir || "."} ${p.path}`,
+            })),
+          ),
     [tool, maven, gradle],
   );
   const [project, setProject] = useState<string | null>(() =>
@@ -44,7 +50,8 @@ function ExecutePopup({ tool }: { tool: BuildTool }) {
       const p = maven?.projects.find((x) => x.pom === project);
       return goalCompletions(line, p?.plugins ?? [], history).slice(0, 200);
     }
-    return gradle ? taskCompletions(line, gradle, history).slice(0, 200) : [];
+    const selected = gradleProjectForKey(gradle ?? [], project);
+    return selected ? taskCompletions(line, selected.build, history).slice(0, 200) : [];
   }, [tool, maven, gradle, project, line, history]);
 
   const close = () => useBuild.setState({ executeOpen: null });
diff --git a/src/features/build-tools/actions.test.tsx b/src/features/build-tools/actions.test.tsx
index af8ffa036..9944b0f00 100644
--- a/src/features/build-tools/actions.test.tsx
+++ b/src/features/build-tools/actions.test.tsx
@@ -36,7 +36,7 @@ const mavenModel: BuildModel = {
     stale: true,
     syncError: null,
   },
-  gradle: null,
+  gradle: [],
 };
 
 describe("build tools feature", () => {
@@ -62,7 +62,7 @@ describe("build tools feature", () => {
     expect(getContext()["build.maven"]).toBe(true);
     expect(toolWindows()).not.toContain("gradle");
 
-    act(() => useBuild.setState({ model: { maven: null, gradle: null } }));
+    act(() => useBuild.setState({ model: { maven: null, gradle: [] } }));
     expect(toolWindows()).not.toContain("maven");
     expect(getContext()["build.maven"]).toBe(false);
   });
diff --git a/src/features/build-tools/autoReload.test.ts b/src/features/build-tools/autoReload.test.ts
index 90eaa015f..1109e2953 100644
--- a/src/features/build-tools/autoReload.test.ts
+++ b/src/features/build-tools/autoReload.test.ts
@@ -28,7 +28,7 @@ vi.mock("@tauri-apps/api/core", async (original) => ({
 
 const maven = (stale: boolean) =>
   ({ syncedAt: 1, stale, syncError: null, profiles: [], projects: [] }) as unknown as MavenModel;
-const model = (stale: boolean): BuildModel => ({ maven: maven(stale), gradle: null });
+const model = (stale: boolean): BuildModel => ({ maven: maven(stale), gradle: [] });
 
 beforeEach(() => {
   vi.clearAllMocks();
diff --git a/src/features/build-tools/index.ts b/src/features/build-tools/index.ts
index a67079868..16dd13137 100644
--- a/src/features/build-tools/index.ts
+++ b/src/features/build-tools/index.ts
@@ -14,16 +14,20 @@ import {
   registerOverlay,
   registerRunAnythingProvider,
   registerToolWindow,
+  toolWindowService,
 } from "@/workbench/contributions";
 import { lazyComponent } from "@/ui";
 import { GradleView, MavenView } from "./BuildToolView";
 import { ExecutePopupHost } from "./ExecutePopup";
 import { buildToolsRunAnything } from "./runAnything";
 import { versionCatalogExtension } from "./versionCatalog";
-import { expandableKeys, gradleChildren, gradleRoots, mavenChildren, mavenRoots } from "./model";
+import { expandableKeys, gradleChildren, gradleRoots, mavenChildren, mavenRoots, gradleProjectKey } from "./model";
 import {
   ANALYZER_KIND,
   addProjects,
+  linkGradleProjects,
+  unlinkGradleProjects,
+  requestSync,
   unlinkProjects,
   cancelSync,
   loadModel,
@@ -33,6 +37,7 @@ import {
   openAnalyzer,
   resetBuild,
   setExpanded,
+  setCurrentProject,
   syncTool,
   toggleGradleOffline,
   toggleMavenOffline,
@@ -55,7 +60,7 @@ function expandAll(tool: BuildTool) {
       tool,
       expandableKeys(mavenRoots(m), (n) => mavenChildren(n, m, configs)),
     );
-  } else if (tool === "gradle" && model?.gradle) {
+  } else if (tool === "gradle" && model?.gradle?.length) {
     const g = model.gradle;
     setExpanded(
       tool,
@@ -84,24 +89,34 @@ function analyzerPom(arg: unknown): string | null {
 /** The analyzer module of a Gradle project from an action argument: `{ gradlePath }`, or `{ path }` of its build script. */
 function analyzerGradle(arg: unknown): string | null {
   const { model, root } = useBuild.getState();
-  const a = (arg ?? {}) as { gradlePath?: unknown; path?: unknown };
-  if (typeof a.gradlePath === "string") return `gradle:${a.gradlePath}`;
-  const project =
-    typeof a.path === "string" && root
-      ? model?.gradle?.projects.find((p) => p.buildFile && `${root}/${p.buildFile}` === a.path)
-      : undefined;
-  return project ? `gradle:${project.path}` : null;
+  const a = (arg ?? {}) as { buildDir?: unknown; gradlePath?: unknown; path?: unknown };
+  for (const build of model?.gradle ?? []) {
+    const project = build.projects.find((p) => {
+      if (typeof a.gradlePath === "string")
+        return p.path === a.gradlePath && (a.buildDir === undefined || a.buildDir === build.dir);
+      const file = p.buildFile;
+      return (
+        typeof a.path === "string" &&
+        root &&
+        file &&
+        (/^(?:[A-Za-z]:[\\/]|\/)/.test(file) ? file : `${root}/${file}`) === a.path
+      );
+    });
+    if (project) return gradleProjectKey(build, project);
+  }
+  return null;
 }
 
 const synced = new Set<string>();
 
 /** Registers / unregisters the tool windows to match the model; first sync of a never-synced build. */
 function apply(model: BuildModel | null, registered: Partial<Record<BuildTool, () => void>>) {
-  const has: Record<BuildTool, boolean> = { maven: !!model?.maven, gradle: !!model?.gradle };
+  const has: Record<BuildTool, boolean> = { maven: !!model?.maven, gradle: !!model?.gradle?.length };
   setContext("build.maven", has.maven);
   setContext("build.gradle", has.gradle);
   for (const tool of ["maven", "gradle"] as const) {
-    if (has[tool] && !registered[tool]) {
+    const visible = has[tool] || (tool === "gradle" && model !== null && !!registered.gradle);
+    if (visible && !registered[tool]) {
       registered[tool] =
         tool === "maven"
           ? registerToolWindow({
@@ -120,25 +135,40 @@ function apply(model: BuildModel | null, registered: Partial<Record<BuildTool, (
               order: 11,
               component: GradleView,
             });
-    } else if (!has[tool] && registered[tool]) {
+    } else if (!visible && registered[tool]) {
       registered[tool]!();
       delete registered[tool];
     }
   }
-  // IDEA imports a build when the project is first opened.
+  // Import each independent build once; linking another build must not be hidden by the first sync.
   const root = useBuild.getState().root;
-  for (const tool of ["maven", "gradle"] as const) {
-    const info = tool === "maven" ? model?.maven : model?.gradle;
-    const key = `${tool}:${root}`;
-    if (info && (tool !== "maven" || model?.maven?.projects.length) && info.syncedAt == null && !synced.has(key)) {
+  const mavenKey = `maven:${root}`;
+  if (model?.maven?.projects.length && model.maven.syncedAt == null && !synced.has(mavenKey)) {
+    synced.add(mavenKey);
+    requestSync("maven");
+  }
+  for (const build of model?.gradle ?? []) {
+    const key = JSON.stringify([root, build.dir]);
+    if (build.syncedAt == null && !synced.has(key)) {
       synced.add(key);
-      void syncTool(tool);
+      requestSync("gradle", build.dir);
     }
   }
 }
 
 export function activate(): () => void {
   const registered: Partial<Record<BuildTool, () => void>> = {};
+  const showGradle = () => {
+    registered.gradle ??= registerToolWindow({
+      id: "gradle",
+      title: "Gradle",
+      icon: "toolwindow-gradle",
+      anchor: "right",
+      order: 11,
+      component: GradleView,
+    });
+    toolWindowService().show("gradle", true);
+  };
   let timer: ReturnType<typeof setTimeout> | undefined;
   const scheduleLoad = () => {
     clearTimeout(timer);
@@ -187,6 +217,7 @@ export function activate(): () => void {
     }),
     useProject.subscribe((s, prev) => {
       if (s.project?.root === prev.project?.root && s.project?.trusted === prev.project?.trusted) return;
+      synced.clear();
       resetBuild();
       if (s.project) void loadModel();
     }),
@@ -207,6 +238,30 @@ export function activate(): () => void {
       if (e.key === "languages" || e.key.startsWith("languages.java")) scheduleLoad();
     }),
     registerActions([
+      {
+        id: "gradle.linkProjects",
+        title: "Link Gradle Projects",
+        category: "Gradle",
+        icon: "plus",
+        when: "projectOpen && !workspaceOpen",
+        run: async () => {
+          showGradle();
+          await linkGradleProjects();
+        },
+      },
+      {
+        id: "gradle.unlinkProjects",
+        title: "Unlink Gradle Project",
+        category: "Gradle",
+        hidden: true,
+        when: `${GRADLE_WHEN} && !workspaceOpen`,
+        run: async ({ arg }) => {
+          const dir = (arg as { buildDir?: unknown } | undefined)?.buildDir;
+          const root = useBuild.getState().root;
+          if (await unlinkGradleProjects(typeof dir === "string" ? dir : null))
+            synced.delete(JSON.stringify([root, dir]));
+        },
+      },
       {
         id: "maven.addProjects",
         title: "Add Maven Projects",
@@ -319,7 +374,10 @@ export function activate(): () => void {
         icon: "refresh",
         when: GRADLE_WHEN,
         keywords: ["gradle", "sync", "refresh"],
-        run: () => syncTool("gradle"),
+        run: ({ arg }) => {
+          const dir = (arg as { buildDir?: unknown } | undefined)?.buildDir;
+          requestSync("gradle", typeof dir === "string" ? dir : null);
+        },
       },
       {
         id: "gradle.analyzeDependencies",
@@ -348,7 +406,11 @@ export function activate(): () => void {
         icon: "run-anything",
         when: GRADLE_WHEN,
         keywords: ["gradle", "task", "run anything"],
-        run: () => openExecute("gradle"),
+        run: ({ arg }) => {
+          const key = (arg as { projectKey?: unknown } | undefined)?.projectKey;
+          if (typeof key === "string") setCurrentProject("gradle", key);
+          openExecute("gradle");
+        },
       },
       {
         id: "gradle.toggleOffline",
@@ -388,6 +450,7 @@ export function activate(): () => void {
     for (const d of Object.values(registered)) d?.();
     setContext("build.maven", false);
     setContext("build.gradle", false);
+    synced.clear();
     resetBuild();
   };
 }
diff --git a/src/features/build-tools/linkage.test.tsx b/src/features/build-tools/linkage.test.tsx
index cb156d22c..2006e1c7c 100644
--- a/src/features/build-tools/linkage.test.tsx
+++ b/src/features/build-tools/linkage.test.tsx
@@ -1,11 +1,13 @@
 import { afterEach, beforeEach, expect, it, vi } from "vitest";
 import { act, fireEvent, render, screen } from "@testing-library/react";
-import { executeAction } from "@/platform/actions";
+import { executeAction, registerAction, allActions, isActionEnabled } from "@/platform/actions";
 import { setContext } from "@/platform/context";
-import type { BuildModel, ProjectInfo } from "@/platform/ipc";
+import type { BuildModel, GradleModel, ProjectInfo, RunConfig } from "@/platform/ipc";
 import { useProject } from "@/platform/project";
-import { MavenView } from "./BuildToolView";
+import { GradleView, MavenView } from "./BuildToolView";
 import { activate } from "./index";
+import { expandableKeys, gradleChildren, gradleRoots, gradleProjectKey } from "./model";
+import { executeBuildLine } from "./runAnything";
 import { useBuild } from "./store";
 
 const mocks = vi.hoisted(() => ({
@@ -16,6 +18,10 @@ const mocks = vi.hoisted(() => ({
   open: vi.fn(),
   confirm: vi.fn(),
   menu: vi.fn(),
+  link: vi.fn(),
+  unlink: vi.fn(),
+  show: vi.fn(),
+  sync: vi.fn(),
 }));
 vi.mock("@/platform/ipc", async (original) => {
   const real = await original<typeof import("@/platform/ipc")>();
@@ -29,9 +35,23 @@ vi.mock("@/platform/ipc", async (original) => {
       settingsSet: mocks.set,
       buildModel: mocks.model,
       runConfigs: mocks.configs,
+      gradleLinkProjects: mocks.link,
+      gradleUnlinkProjects: mocks.unlink,
+      buildSync: mocks.sync,
+      cancelRequest: () => Promise.resolve(),
     },
   };
 });
+vi.mock("@tauri-apps/api/core", async (original) => ({
+  ...(await original<typeof import("@tauri-apps/api/core")>()),
+  Channel: class {
+    onmessage: unknown = null;
+  },
+}));
+vi.mock("@/workbench/contributions", async (original) => ({
+  ...(await original<typeof import("@/workbench/contributions")>()),
+  toolWindowService: () => ({ show: mocks.show }),
+}));
 vi.mock("@tauri-apps/plugin-dialog", () => ({ open: mocks.open }));
 vi.mock("@/workbench/messages", () => ({ confirm: mocks.confirm }));
 vi.mock("@/ui", async (original) => ({
@@ -40,7 +60,7 @@ vi.mock("@/ui", async (original) => ({
 }));
 
 const model: BuildModel = {
-  gradle: null,
+  gradle: [],
   maven: {
     syncedAt: 1,
     stale: false,
@@ -81,6 +101,7 @@ beforeEach(async () => {
   mocks.confirm.mockResolvedValue(true);
   useProject.setState({ project: { root: "/p" } as ProjectInfo });
   setContext("projectOpen", true);
+  setContext("workspaceOpen", false);
   await act(async () => {
     dispose = activate();
   });
@@ -204,3 +225,173 @@ it.each([null, "/outside/pom.xml", "/p/a/build.xml", "/p/../outside/pom.xml", "/
     expect(mocks.set).not.toHaveBeenCalled();
   },
 );
+
+it("links picked POMs that no reactor lists as independent top-level projects", async () => {
+  mocks.get.mockResolvedValue({
+    languages: { java: { maven: { unlinkedProjects: ["b/pom.xml"], linkedProjects: ["tools/pom.xml"] } } },
+  });
+  mocks.open.mockResolvedValue(["/p/stub/pom.xml", "/p/b/pom.xml", "/p/a/pom.xml", "/p/tools/pom.xml"]);
+  await act(async () => {
+    await executeAction("maven.addProjects");
+  });
+  expect(mocks.open).toHaveBeenCalledWith(expect.objectContaining({ multiple: true }));
+  expect(mocks.set).toHaveBeenCalledWith("project", "languages.java.maven.unlinkedProjects", "[]");
+  expect(mocks.set).toHaveBeenCalledWith(
+    "project",
+    "languages.java.maven.linkedProjects",
+    '["tools/pom.xml","stub/pom.xml"]',
+  );
+});
+
+it("unlinking a linked independent project removes the link instead of hiding it", async () => {
+  mocks.get.mockResolvedValue({ languages: { java: { maven: { linkedProjects: ["a/pom.xml"] } } } });
+  await act(async () => {
+    await executeAction("maven.unlinkProjects", { pom: "a/pom.xml" });
+  });
+  expect(mocks.set).toHaveBeenCalledWith("project", "languages.java.maven.linkedProjects", "[]");
+  expect(mocks.set).not.toHaveBeenCalledWith("project", "languages.java.maven.unlinkedProjects", expect.anything());
+});
+
+const gradleBuild = (dir: string): GradleModel => ({
+  dir,
+  command: `/p/${dir}/gradlew`,
+  env: { JAVA_HOME: `/${dir}/jdk` },
+  javaVersion: 21,
+  syncedAt: 1,
+  stale: false,
+  syncError: null,
+  projects: [
+    { path: ":", name: dir, dir, buildFile: `${dir}/build.gradle`, tasks: [] },
+    {
+      path: ":app",
+      name: "app",
+      dir: `${dir}/app`,
+      buildFile: `${dir}/app/build.gradle`,
+      tasks: [{ name: "test", group: "verification", description: null }],
+    },
+  ],
+});
+
+it("links from the toolbar and keeps Link available after unlinking the final build", async () => {
+  const build = gradleBuild("first");
+  const linked: BuildModel = { maven: null, gradle: [build] };
+  mocks.link.mockResolvedValue(linked);
+  mocks.unlink.mockResolvedValue({ maven: null, gradle: [] });
+  mocks.open.mockResolvedValue(["/p/first/settings.gradle"]);
+  act(() => useBuild.setState({ model: { maven: null, gradle: [] } }));
+  render(<GradleView />);
+  await act(async () => fireEvent.click(screen.getByRole("button", { name: "Link Gradle Projects" })));
+  expect(mocks.link).toHaveBeenCalledWith(["/p/first/settings.gradle"]);
+  expect(screen.getByText("first")).toBeTruthy();
+  fireEvent.contextMenu(screen.getByText("first"));
+  expect(mocks.menu).toHaveBeenCalledWith(
+    expect.anything(),
+    expect.arrayContaining([expect.objectContaining({ action: "gradle.unlinkProjects", arg: { buildDir: "first" } })]),
+  );
+  await act(async () => executeAction("gradle.unlinkProjects", { buildDir: "first" }));
+  expect(mocks.unlink).toHaveBeenCalledWith(["first"]);
+  expect(mocks.confirm).toHaveBeenCalledWith(
+    expect.objectContaining({ message: expect.stringContaining("Files will remain") }),
+  );
+  expect(screen.getByText("No Gradle projects")).toBeTruthy();
+  expect(screen.getByRole("button", { name: "Link Gradle Projects" })).toBeTruthy();
+  expect(useBuild.getState().model?.gradle).toEqual([]);
+});
+
+it("leaves links unchanged when unlink is cancelled or a module is targeted", async () => {
+  act(() => useBuild.setState({ model: { maven: null, gradle: [gradleBuild("first")] } }));
+  mocks.confirm.mockResolvedValue(false);
+  await executeAction("gradle.unlinkProjects", { buildDir: "first" });
+  await executeAction("gradle.unlinkProjects", { buildDir: "first/app" });
+  expect(mocks.unlink).not.toHaveBeenCalled();
+  expect(useBuild.getState().model?.gradle).toHaveLength(1);
+});
+
+it("runs duplicate task paths with the selected build's wrapper, cwd and offline setting", async () => {
+  const builds = [gradleBuild("first"), gradleBuild("second")];
+  const model: BuildModel = { maven: null, gradle: builds };
+  const roots = gradleRoots(builds);
+  const expanded = expandableKeys(roots, (n) => gradleChildren(n, builds, [], "/p"));
+  act(() =>
+    useBuild.setState({
+      model,
+      expanded: { maven: new Set(), gradle: expanded },
+      current: { gradle: gradleProjectKey(builds[1]!, builds[1]!.projects[1]!) },
+      settings: { ...useBuild.getState().settings, gradle: { offline: true } },
+    }),
+  );
+  const started: RunConfig[] = [];
+  const off = registerAction({
+    id: "run.runConfig",
+    title: "Run",
+    hidden: true,
+    run: ({ arg }) => {
+      started.push((arg as { config: RunConfig }).config);
+    },
+  });
+  render(<GradleView />);
+  const tasks = screen.getAllByText("test");
+  expect(tasks).toHaveLength(2);
+  await act(async () => fireEvent.doubleClick(tasks[1]!));
+  expect(executeBuildLine("gradle", "test")).toBe(true);
+  off();
+  expect(started).toHaveLength(2);
+  for (const config of started)
+    expect(config).toMatchObject({
+      command: "/p/second/gradlew",
+      cwd: "second",
+      args: [":app:test", "--offline"],
+      env: { JAVA_HOME: "/second/jdk" },
+    });
+});
+
+it("drops a late link result after the user changes projects", async () => {
+  let finish!: (model: BuildModel) => void;
+  mocks.open.mockResolvedValue("/p/first/build.gradle");
+  mocks.link.mockImplementation(
+    () =>
+      new Promise<BuildModel>((resolve) => {
+        finish = resolve;
+      }),
+  );
+  const pending = executeAction("gradle.linkProjects");
+  await vi.waitFor(() => expect(mocks.link).toHaveBeenCalled());
+  await act(async () => {
+    useProject.setState({ project: { root: "/other", trusted: false } as ProjectInfo });
+    finish({ maven: null, gradle: [gradleBuild("first")] });
+    await pending;
+  });
+  expect(useBuild.getState().model).toBeNull();
+});
+
+it("routes Reload to the chosen independent build", async () => {
+  const model: BuildModel = { maven: null, gradle: [gradleBuild("first"), gradleBuild("second")] };
+  mocks.sync.mockResolvedValue(model);
+  act(() => useBuild.setState({ model }));
+  await executeAction("gradle.reload", { buildDir: "second" });
+  await vi.waitFor(() =>
+    expect(mocks.sync).toHaveBeenCalledWith("gradle", expect.any(Number), false, [], "second", expect.anything()),
+  );
+});
+
+it("does not offer Link or Unlink for a native Workspace window", async () => {
+  act(() =>
+    useProject.setState({
+      project: { root: "/p", workspace: { version: 1, name: "workspace", projects: ["/p/first"] } } as ProjectInfo,
+    }),
+  );
+  setContext("workspaceOpen", true);
+  for (const id of ["gradle.linkProjects", "gradle.unlinkProjects"])
+    expect(isActionEnabled(allActions().find((a) => a.id === id)!)).toBe(false);
+  await executeAction("gradle.linkProjects");
+  expect(mocks.open).not.toHaveBeenCalled();
+  expect(mocks.link).not.toHaveBeenCalled();
+});
+
+it("does not link or start Gradle imports in an untrusted project", async () => {
+  act(() => useProject.setState({ project: { root: "/p", trusted: false } as ProjectInfo }));
+  await executeAction("gradle.linkProjects");
+  expect(mocks.open).not.toHaveBeenCalled();
+  expect(mocks.link).not.toHaveBeenCalled();
+  expect(mocks.sync).not.toHaveBeenCalled();
+});
diff --git a/src/features/build-tools/model.test.ts b/src/features/build-tools/model.test.ts
index 40754abc2..ec0fa2a5e 100644
--- a/src/features/build-tools/model.test.ts
+++ b/src/features/build-tools/model.test.ts
@@ -5,6 +5,8 @@ import {
   goalCompletions,
   gradleChildren,
   gradleRoots,
+  gradleRunConfigs,
+  gradleProjectKey,
   gradleTaskConfig,
   isRunnable,
   mavenChildren,
@@ -284,10 +286,10 @@ describe("Gradle tree and runs", () => {
     syncError: null,
   };
   const kids = (n: BuildNode) =>
-    gradleChildren(n, gradle, [runConfig({ id: "g", name: "app [run]", kind: "gradle" })]) ?? [];
+    gradleChildren(n, [gradle], [runConfig({ id: "g", name: "app [run]", kind: "gradle" })]) ?? [];
 
   it("nests subprojects and groups tasks, other last", () => {
-    const roots = gradleRoots(gradle);
+    const roots = gradleRoots([gradle]);
     expect(labels(roots)).toEqual(["gradle-demo"]);
     expect(labels(kids(roots[0]!))).toEqual(["Tasks", "Run Configurations", "app", "core"]);
     const app = kids(roots[0]!)[2]!;
@@ -315,6 +317,65 @@ describe("Gradle tree and runs", () => {
     ]);
   });
 
+  it("keeps identical project paths and tasks of independent builds distinct", () => {
+    const builds = ["first", "second"].map((dir) => ({
+      ...gradle,
+      dir,
+      command: `/p/${dir}/gradlew`,
+      env: { JAVA_HOME: `/${dir}/jdk` },
+      projects: gradle.projects.map((p) => ({ ...p, dir: `${dir}/${p.dir}`.replace(/\/$/, "") })),
+    }));
+    const roots = gradleRoots(builds);
+    expect(new Set(roots.map((n) => n.key)).size).toBe(2);
+    const tasks = roots.map((r) => {
+      const app = gradleChildren(r, builds, [])!.find((n) => n.kind === "gradleProject" && n.project.path === ":app")!;
+      const folder = gradleChildren(app, builds, [])![0]!;
+      const group = gradleChildren(folder, builds, [])!.find(
+        (n) => n.kind === "taskGroup" && n.group === "verification",
+      )!;
+      return gradleChildren(group, builds, [])![0]!;
+    });
+    expect(tasks[0]!.key).not.toBe(tasks[1]!.key);
+    const runs = builds.map((b) => gradleTaskConfig(b, b.projects[1]!, ["test"], { offline: true }));
+    expect(runs[0]!.id).not.toBe(runs[1]!.id);
+    expect(runs[1]).toMatchObject({
+      command: "/p/second/gradlew",
+      cwd: "second",
+      env: { JAVA_HOME: "/second/jdk" },
+      args: [":app:test", "--offline"],
+    });
+    expect(gradleProjectKey(builds[1]!, builds[1]!.projects[1]!)).toBe('gradle:["second",":app"]');
+  });
+
+  it("shows run configurations only under their owning linked build", () => {
+    const nested = {
+      ...gradle,
+      dir: "nested",
+      projects: gradle.projects.map((p) => ({ ...p, dir: `nested/${p.dir}` })),
+    };
+    const configs = [
+      runConfig({ id: "root", kind: "gradle", cwd: "app" }),
+      runConfig({ id: "nested", kind: "gradle", cwd: "nested/app" }),
+      runConfig({ id: "absolute", kind: "gradle", cwd: "/p/nested/app" }),
+      runConfig({ id: "other", kind: "maven", cwd: "nested" }),
+    ];
+    expect(gradleRunConfigs(gradle, [gradle, nested], configs, "/p").map((c) => c.id)).toEqual(["root"]);
+    expect(gradleRunConfigs(nested, [gradle, nested], configs, "/p").map((c) => c.id)).toEqual(["nested", "absolute"]);
+  });
+
+  it("places a saved run under its directly linked root instead of a longer sibling composite", () => {
+    const composite = {
+      ...gradle,
+      dir: "very-long-composite",
+      projects: [{ ...gradle.projects[1]!, path: ":b:app", dir: "b/app", build: ":b" }],
+    };
+    const direct = { ...gradle, dir: "b", projects: [{ ...gradle.projects[1]!, dir: "b/app" }] };
+    const saved = runConfig({ id: "saved", kind: "gradle", cwd: "b/app" });
+    const builds = [composite, direct];
+    expect(gradleRunConfigs(composite, builds, [saved], "/p")).toEqual([]);
+    expect(gradleRunConfigs(direct, builds, [saved], "/p")).toEqual([saved]);
+  });
+
   it("completes task names and paths", () => {
     const labelsOf = taskCompletions("ru", gradle).map((c) => c.label);
     expect(labelsOf).toEqual([":app:run"]);
diff --git a/src/features/build-tools/model.ts b/src/features/build-tools/model.ts
index c448ee943..398dc6539 100644
--- a/src/features/build-tools/model.ts
+++ b/src/features/build-tools/model.ts
@@ -67,10 +67,10 @@ export type BuildNode =
   | { kind: "dependency"; key: string; dependency: MavenDependency }
   | { kind: "runConfigs"; key: string; configs: RunConfig[] }
   | { kind: "runConfig"; key: string; config: RunConfig }
-  | { kind: "gradleProject"; key: string; project: GradleProject }
-  | { kind: "tasks"; key: string; project: GradleProject }
-  | { kind: "taskGroup"; key: string; project: GradleProject; group: string; tasks: GradleTask[] }
-  | { kind: "task"; key: string; project: GradleProject; task: GradleTask };
+  | { kind: "gradleProject"; key: string; build: GradleModel; project: GradleProject }
+  | { kind: "tasks"; key: string; build: GradleModel; project: GradleProject }
+  | { kind: "taskGroup"; key: string; build: GradleModel; project: GradleProject; group: string; tasks: GradleTask[] }
+  | { kind: "task"; key: string; build: GradleModel; project: GradleProject; task: GradleTask };
 
 /** Options applied to every Maven run (toolbar toggles, Profiles checkboxes). */
 export interface MavenRunOptions {
@@ -133,9 +133,28 @@ export function mavenRunConfigs(project: MavenProject, configs: readonly RunConf
   return configs.filter((c) => c.kind === "maven" && normalizeDir(c.cwd) === project.dir);
 }
 
-/** Run configurations of a Gradle build: every `gradle` config. */
-export function gradleRunConfigs(configs: readonly RunConfig[]): RunConfig[] {
-  return configs.filter((c) => c.kind === "gradle");
+/** Run configurations under this build, with nested independent builds owning their own runs. */
+export function gradleRunConfigs(
+  model: GradleModel,
+  models: readonly GradleModel[],
+  configs: readonly RunConfig[],
+  root: string,
+): RunConfig[] {
+  const absolute = (path: string) =>
+    /^(?:[A-Za-z]:[\\/]|\/)/.test(path) ? normalizeDir(path) : normalizeDir(`${root}/${path}`);
+  return configs.filter((c) => {
+    if (c.kind !== "gradle") return false;
+    const cwd = absolute(c.cwd ?? "");
+    const contains = (dir: string) => cwd === dir || cwd.startsWith(`${dir}/`);
+    const ownerDepth = (build: GradleModel) => {
+      const dir = absolute(build.dir);
+      return contains(dir) ? dir.split("/").length : 0;
+    };
+    const owners = models
+      .filter((build) => [build.dir, ...build.projects.map((p) => p.dir)].some((dir) => contains(absolute(dir))))
+      .sort((a, b) => ownerDepth(b) - ownerDepth(a));
+    return owners[0]?.dir === model.dir;
+  });
 }
 
 function normalizeDir(cwd: string | null | undefined): string {
@@ -230,9 +249,26 @@ export function gradleTaskGroups(project: GradleProject): Array<{ group: string;
     .map(([group, tasks]) => ({ group, tasks: [...tasks].sort((a, b) => a.name.localeCompare(b.name)) }));
 }
 
-export function gradleRoots(model: GradleModel): BuildNode[] {
-  const root = model.projects.find((p) => p.path === ":") ?? model.projects[0];
-  return root ? [{ kind: "gradleProject", key: `gradle:${root.path}`, project: root }] : [];
+/** Identity of a project within one independently linked build. */
+export const gradleProjectKey = (build: Pick<GradleModel, "dir">, project: Pick<GradleProject, "path">) =>
+  `gradle:${JSON.stringify([build.dir, project.path])}`;
+
+export function gradleProjectForKey(models: readonly GradleModel[], key: string | null | undefined) {
+  for (const build of models) {
+    const project = build.projects.find((p) => gradleProjectKey(build, p) === key);
+    if (project) return { build, project };
+  }
+  if (key != null) return null;
+  const build = models[0];
+  const project = build?.projects[0];
+  return build && project ? { build, project } : null;
+}
+
+export function gradleRoots(models: readonly GradleModel[]): BuildNode[] {
+  return models.flatMap((build) => {
+    const root = build.projects.find((p) => p.path === ":") ?? build.projects[0];
+    return root ? [{ kind: "gradleProject" as const, key: gradleProjectKey(build, root), build, project: root }] : [];
+  });
 }
 
 /** Direct subprojects of `path` (`:a` and `:b` under `:`, `:a:x` under `:a`). */
@@ -248,31 +284,39 @@ export function gradleSubprojects(model: GradleModel, path: string): GradleProje
 
 export function gradleChildren(
   node: BuildNode,
-  model: GradleModel,
+  models: readonly GradleModel[],
   configs: readonly RunConfig[],
+  root = "",
 ): BuildNode[] | undefined {
   switch (node.kind) {
     case "gradleProject": {
       const p = node.project;
-      const out: BuildNode[] = [{ kind: "tasks", key: `${node.key}:tasks`, project: p }];
+      const out: BuildNode[] = [{ kind: "tasks", key: `${node.key}:tasks`, build: node.build, project: p }];
       if (p.path === ":") {
-        const runs = gradleRunConfigs(configs);
+        const runs = gradleRunConfigs(node.build, models, configs, root);
         if (runs.length) out.push({ kind: "runConfigs", key: `${node.key}:runs`, configs: runs });
       }
-      for (const sub of gradleSubprojects(model, p.path))
-        out.push({ kind: "gradleProject", key: `gradle:${sub.path}`, project: sub });
+      for (const sub of gradleSubprojects(node.build, p.path))
+        out.push({ kind: "gradleProject", key: gradleProjectKey(node.build, sub), build: node.build, project: sub });
       return out;
     }
     case "tasks":
       return gradleTaskGroups(node.project).map(({ group, tasks }) => ({
         kind: "taskGroup",
         key: `${node.key}:${group}`,
+        build: node.build,
         project: node.project,
         group,
         tasks,
       }));
     case "taskGroup":
-      return node.tasks.map((task) => ({ kind: "task", key: `${node.key}:${task.name}`, project: node.project, task }));
+      return node.tasks.map((task) => ({
+        kind: "task",
+        key: `${node.key}:${task.name}`,
+        build: node.build,
+        project: node.project,
+        task,
+      }));
     case "runConfigs":
       return node.configs.map((config) => ({ kind: "runConfig", key: `${node.key}:${config.id}`, config }));
     default:
@@ -456,7 +500,7 @@ export function gradleTaskConfig(
   if (options.offline && !args.includes("--offline")) args.push("--offline");
   const names = tasks.filter((t) => !t.startsWith("-"));
   return {
-    id: `gradle:task:${project.path}:${tasks.join(" ")}`,
+    id: `gradle:task:${JSON.stringify([model.dir, project.path])}:${tasks.join(" ")}`,
     name: `${project.name} [${names.join(",")}]`,
     kind: "gradle",
     command: model.command,
diff --git a/src/features/build-tools/profileReload.test.ts b/src/features/build-tools/profileReload.test.ts
index 6f2bf0d13..5bc318eac 100644
--- a/src/features/build-tools/profileReload.test.ts
+++ b/src/features/build-tools/profileReload.test.ts
@@ -37,7 +37,7 @@ const maven = {
   ],
   projects: [],
 } as unknown as MavenModel;
-const model: BuildModel = { maven, gradle: null };
+const model: BuildModel = { maven, gradle: [] };
 
 /** The `-P` entries each sync was started with. */
 const syncedProfiles = () => mocks.sync.mock.calls.map((c) => c[3] as string[]);
diff --git a/src/features/build-tools/runAnything.ts b/src/features/build-tools/runAnything.ts
index 146b6c1c3..0861ccbe8 100644
--- a/src/features/build-tools/runAnything.ts
+++ b/src/features/build-tools/runAnything.ts
@@ -8,6 +8,7 @@ import type { RunAnythingItem, RunAnythingProvider } from "@/workbench/contribut
 import {
   goalCompletions,
   gradleTaskConfig,
+  gradleProjectForKey,
   mavenGoalConfig,
   parseGoalLine,
   parseTaskLine,
@@ -25,19 +26,20 @@ const WORD: Record<BuildTool, string> = { maven: "mvn", gradle: "gradle" };
 export function lineTool(line: string): BuildTool | null {
   const model = useBuild.getState().model;
   if (model?.maven && COMMANDS.maven.test(line)) return "maven";
-  if (model?.gradle && COMMANDS.gradle.test(line)) return "gradle";
+  if (model?.gradle?.length && COMMANDS.gradle.test(line)) return "gradle";
   return null;
 }
 
 /** The project a line runs in: the given one, else the tool window's current one, else the first. */
-function projectFor(tool: BuildTool, key?: string | null) {
+function mavenProjectFor(key?: string | null) {
   const { model, current } = useBuild.getState();
-  if (tool === "maven") {
-    const projects = model?.maven?.projects ?? [];
-    return projects.find((p) => p.pom === (key ?? current.maven)) ?? projects[0];
-  }
-  const projects = model?.gradle?.projects ?? [];
-  return projects.find((p) => p.path === (key ?? current.gradle)) ?? projects[0];
+  const projects = model?.maven?.projects ?? [];
+  return projects.find((p) => p.pom === (key ?? current.maven)) ?? projects[0];
+}
+
+function gradleProjectFor(key?: string | null) {
+  const { model, current } = useBuild.getState();
+  return gradleProjectForKey(model?.gradle ?? [], key ?? current.gradle);
 }
 
 /** Runs goals / tasks typed for `tool` in a project; false when there is nothing to run. */
@@ -45,28 +47,27 @@ export function executeBuildLine(tool: BuildTool, text: string, projectKey?: str
   const { model, settings } = useBuild.getState();
   if (tool === "maven") {
     const maven = model?.maven;
-    const project = projectFor("maven", projectKey);
+    const project = mavenProjectFor(projectKey);
     const goals = parseGoalLine(text);
     if (!maven || !project || !("pom" in project) || !goals.length) return false;
     runConfig(mavenGoalConfig(project, goals, maven, settings.maven), "run");
   } else {
-    const gradle = model?.gradle;
-    const project = projectFor("gradle", projectKey);
+    const selected = gradleProjectFor(projectKey);
     const tasks = parseTaskLine(text);
-    if (!gradle || !project || "pom" in project || !tasks.length) return false;
-    runConfig(gradleTaskConfig(gradle, project, tasks, settings.gradle), "run");
+    if (!selected || !tasks.length) return false;
+    runConfig(gradleTaskConfig(selected.build, selected.project, tasks, settings.gradle), "run");
   }
   pushHistory(tool, text.replace(COMMANDS[tool], "").trim());
   return true;
 }
 
 function completions(tool: BuildTool, rest: string) {
-  const model = useBuild.getState().model;
   if (tool === "maven") {
-    const project = projectFor("maven");
+    const project = mavenProjectFor();
     return goalCompletions(rest, project && "pom" in project ? project.plugins : [], readHistory("maven"));
   }
-  return model?.gradle ? taskCompletions(rest, model.gradle, readHistory("gradle")) : [];
+  const selected = gradleProjectFor();
+  return selected ? taskCompletions(rest, selected.build, readHistory("gradle")) : [];
 }
 
 export const buildToolsRunAnything: RunAnythingProvider = {
diff --git a/src/features/build-tools/store.ts b/src/features/build-tools/store.ts
index 09df0d84a..c4976709b 100644
--- a/src/features/build-tools/store.ts
+++ b/src/features/build-tools/store.ts
@@ -27,7 +27,7 @@ import { useBuildModel } from "@/platform/buildModel";
 import { useProject } from "@/platform/project";
 import { editorService, notifications } from "@/workbench/contributions";
 import { cancelTask, removeTask, upsertTask, useTasks } from "@/workbench/tasks";
-import { profilesList, type GradleRunOptions, type MavenRunOptions } from "./model";
+import { gradleRoots, profilesList, type GradleRunOptions, type MavenRunOptions } from "./model";
 
 export interface BuildSettings {
   maven: MavenRunOptions;
@@ -58,7 +58,7 @@ interface BuildState {
   expanded: Record<BuildTool, Set<string>>;
   /** Execute Goal / Task popup. */
   executeOpen: BuildTool | null;
-  /** Project selected in each tree (Maven `pom`, Gradle path): where Execute Goal runs. */
+  /** Project selected in each tree (Maven `pom`, Gradle build/project key): where commands run. */
   current: Partial<Record<BuildTool, string>>;
 }
 
@@ -198,9 +198,6 @@ export function changedOutsideIde(paths: readonly string[], now = Date.now()): b
   return external;
 }
 
-/** Root whose never-synced Gradle build was imported on open (once per open). */
-let autoImported: string | null = null;
-
 /** Re-reads the build model (and the run configurations) of the open project. */
 export async function loadModel(): Promise<void> {
   const root = useProject.getState().project?.root ?? null;
@@ -230,26 +227,39 @@ export async function loadModel(): Promise<void> {
       const maven = model.maven;
       if (maven?.stale && maven.syncedAt !== null && !useBuild.getState().syncing.maven) void syncTool("maven");
     }
-    // Like IDEA, a Gradle build is imported when first opened; later changes wait for Reload.
-    if (model.gradle && model.gradle.syncedAt === null && autoImported !== root) {
-      autoImported = root;
-      void syncTool("gradle");
-    }
   } catch (e) {
     if (gen === generation) useBuild.setState({ loading: false, error: e instanceof Error ? e.message : String(e) });
   }
 }
 
 const UNLINKED_PROJECTS = "languages.java.maven.unlinkedProjects";
+const LINKED_PROJECTS = "languages.java.maven.linkedProjects";
 
-async function setLinked(root: string, pom: string, linked: boolean) {
+/**
+ * Adds `poms` to Maven (back from unlinked, or as independent top-level projects when no
+ * reactor lists them), or removes them (a linked one is dropped, a discovered one unlinked).
+ */
+async function setLinked(root: string, poms: string[], linked: boolean) {
   if (useProject.getState().project?.root !== root) return;
   const settings = await commands.settingsGet();
   if (useProject.getState().project?.root !== root) return;
-  const previous = settings.languages.java?.maven?.unlinkedProjects ?? [];
-  const next = linked ? previous.filter((p) => p !== pom) : [...new Set([...previous, pom])];
-  if (JSON.stringify(next) === JSON.stringify(previous)) return;
-  await call(commands.settingsSet("project", UNLINKED_PROJECTS, JSON.stringify(next)));
+  const maven = settings.languages.java?.maven;
+  const unlinkedBefore = maven?.unlinkedProjects ?? [];
+  const linkedBefore = maven?.linkedProjects ?? [];
+  const known = new Set(useBuild.getState().model?.maven?.projects.map((p) => p.pom));
+  let unlinked = unlinkedBefore;
+  let extra = linkedBefore;
+  for (const pom of poms) {
+    if (linked && unlinked.includes(pom)) unlinked = unlinked.filter((p) => p !== pom);
+    else if (linked) {
+      if (!known.has(pom) && !extra.includes(pom)) extra = [...extra, pom];
+    } else if (extra.includes(pom)) extra = extra.filter((p) => p !== pom);
+    else if (!unlinked.includes(pom)) unlinked = [...unlinked, pom];
+  }
+  if (unlinked === unlinkedBefore && extra === linkedBefore) return;
+  if (unlinked !== unlinkedBefore)
+    await call(commands.settingsSet("project", UNLINKED_PROJECTS, JSON.stringify(unlinked)));
+  if (extra !== linkedBefore) await call(commands.settingsSet("project", LINKED_PROJECTS, JSON.stringify(extra)));
   await loadModel();
 }
 
@@ -268,7 +278,19 @@ export async function unlinkProjects(pom: string | null) {
   )
     return;
   cancelSync("maven");
-  await setLinked(root, pom, false);
+  await setLinked(root, [pom], false);
+}
+
+/** Project-relative `pom.xml` paths of `picked` inside `root`; others are skipped. */
+function projectPoms(root: string, picked: readonly string[]): string[] {
+  const base = root.replace(/\\/g, "/").replace(/\/$/, "");
+  return picked.flatMap((p) => {
+    const path = p.replace(/\\/g, "/");
+    if (!path.startsWith(`${base}/`)) return [];
+    const pom = path.slice(base.length + 1);
+    const parts = pom.split("/");
+    return parts.some((part) => part === ".." || part === ".") || parts.pop() !== "pom.xml" ? [] : [pom];
+  });
 }
 
 export async function addProjects() {
@@ -278,43 +300,104 @@ export async function addProjects() {
   const picked = await open({
     title: tx`Add Maven Projects`,
     directory: false,
-    multiple: false,
+    multiple: true,
     defaultPath: root,
     filters: [{ name: "pom.xml", extensions: ["xml"] }],
   });
-  if (typeof picked !== "string") return;
-  const base = root.replace(/\\/g, "/").replace(/\/$/, "");
-  const path = picked.replace(/\\/g, "/");
-  if (!path.startsWith(`${base}/`)) return;
-  const pom = path.slice(base.length + 1);
-  if (pom.split("/").some((part) => part === ".." || part === ".") || pom.split("/").pop() !== "pom.xml") return;
-  await setLinked(root, pom, true);
+  const poms = projectPoms(root, typeof picked === "string" ? [picked] : (picked ?? []));
+  if (poms.length) await setLinked(root, poms, true);
+}
+
+/** Links independent Gradle builds without changing their files or build scripts. */
+export async function linkGradleProjects() {
+  const gen = generation;
+  const root = useProject.getState().project?.root;
+  if (
+    !root ||
+    useProject.getState().project?.workspace ||
+    useProject.getState().project?.trusted === false ||
+    !isTauri()
+  )
+    return;
+  const { open } = await import("@tauri-apps/plugin-dialog");
+  const picked = await open({
+    title: tx`Link Gradle Projects`,
+    directory: false,
+    multiple: true,
+    defaultPath: root,
+    filters: [{ name: "Gradle build files", extensions: ["gradle", "kts"] }],
+  });
+  const paths = typeof picked === "string" ? [picked] : picked;
+  if (!paths?.length || useProject.getState().project?.root !== root || gen !== generation) return;
+  const model = await call(commands.gradleLinkProjects(paths));
+  if (useProject.getState().project?.root !== root || gen !== generation) return;
+  const configs = await call(commands.runConfigs()).catch(() => useBuild.getState().configs);
+  if (useProject.getState().project?.root === root && gen === generation)
+    useBuild.setState((s) => ({
+      model,
+      configs,
+      expanded: {
+        ...s.expanded,
+        gradle: new Set([...s.expanded.gradle, ...initialExpanded("gradle", model)]),
+      },
+    }));
+}
+
+export async function unlinkGradleProjects(buildDir: string | null) {
+  const expectedGeneration = generation;
+  const { root, model } = useBuild.getState();
+  const build = model?.gradle?.find((g) => g.dir === buildDir);
+  if (
+    !root ||
+    useProject.getState().project?.workspace ||
+    !build ||
+    !(await confirm({
+      title: "Unlink Gradle project?",
+      message:
+        "Remove this build from Gradle? Files will remain in the Project view; link its build file again to restore it.",
+      ok: "Unlink",
+    }))
+  )
+    return;
+  if (useProject.getState().project?.root !== root || expectedGeneration !== generation) return;
+  const gen = ++generation;
+  queuedSyncs.delete("gradle");
+  cancelSync("gradle");
+  const next = await call(commands.gradleUnlinkProjects([build.dir]));
+  if (useProject.getState().project?.root !== root || gen !== generation) return;
+  const configs = await call(commands.runConfigs()).catch(() => useBuild.getState().configs);
+  if (useProject.getState().project?.root !== root || gen !== generation) return;
+  useBuild.setState({ model: next, configs, current: { ...useBuild.getState().current, gradle: undefined } });
+  return true;
 }
 
 /** Tree keys expanded on first show: the top-level projects. */
 export function initialExpanded(tool: BuildTool, model: BuildModel): Set<string> {
   if (tool === "maven")
     return new Set(model.maven?.projects.filter((p) => !p.aggregated).map((p) => `mvn:${p.pom}`) ?? []);
-  return new Set(model.gradle ? ["gradle::"] : []);
+  return new Set(gradleRoots(model.gradle ?? []).map((n) => n.key));
 }
 
 const TITLES: Record<BuildTool, string> = { maven: "Syncing Maven projects", gradle: "Syncing Gradle projects" };
 
 /** Tools to sync again once their running sync ends: its options changed meanwhile. */
-const queuedSyncs = new Set<BuildTool>();
+const queuedSyncs = new Map<BuildTool, Set<string | null>>();
 
 /** Syncs `tool` now, or right after the sync in progress (which used the previous options). */
-export function requestSync(tool: BuildTool) {
-  if (useBuild.getState().syncing[tool]) queuedSyncs.add(tool);
-  else void syncTool(tool);
+export function requestSync(tool: BuildTool, buildDir: string | null = null) {
+  if (useBuild.getState().syncing[tool]) {
+    const queued = queuedSyncs.get(tool) ?? new Set<string | null>();
+    queued.add(buildDir);
+    queuedSyncs.set(tool, queued);
+  } else void syncTool(tool, buildDir);
 }
 
-/** Reloads all projects of `tool` from the build tool itself (effective POM, dependency tree, task list). */
-export async function syncTool(tool: BuildTool): Promise<void> {
+/** Reloads the build tool model; `buildDir` limits a Gradle reload to one linked build. */
+export async function syncTool(tool: BuildTool, buildDir: string | null = null): Promise<void> {
   const state = useBuild.getState();
   const gen = generation;
   const root = state.root;
-  if (!root || !isTauri() || state.syncing[tool]) return;
+  if (!root || useProject.getState().project?.trusted === false || !isTauri() || state.syncing[tool]) return;
   const request = nextRequestId();
   const taskId = `build-sync:${tool}`;
   const cancel = () => void commands.cancelRequest(request);
@@ -331,11 +414,18 @@ export async function syncTool(tool: BuildTool): Promise<void> {
   const profiles = tool === "maven" && model?.maven ? profilesList(model.maven.profiles, settings.maven.profiles) : [];
   const offline = tool === "maven" ? settings.maven.offline : settings.gradle.offline;
   try {
-    const next = await call(commands.buildSync(tool, request, offline, profiles, channel));
+    const next = await call(commands.buildSync(tool, request, offline, profiles, buildDir, channel));
     if (useBuild.getState().root !== root || gen !== generation) return;
     const configs = await call(commands.runConfigs()).catch(() => useBuild.getState().configs);
+    if (useBuild.getState().root !== root || gen !== generation) return;
     useBuild.setState({ model: next, configs });
-    const error = tool === "maven" ? next.maven?.syncError : next.gradle?.syncError;
+    const error =
+      tool === "maven"
+        ? next.maven?.syncError
+        : (next.gradle ?? [])
+            .map((g) => g.syncError)
+            .filter(Boolean)
+            .join("\n");
     if (error)
       notifications().notify({
         group: "run",
@@ -355,13 +445,22 @@ export async function syncTool(tool: BuildTool): Promise<void> {
         key: `build-sync-${tool}`,
       });
   } finally {
-    if (useBuild.getState().syncing[tool]?.request === request) setSync(undefined);
-    upsertTask({ id: taskId, title: TITLES[tool], message: null, fraction: 1, done: true });
-    if (queuedSyncs.delete(tool) && gen === generation) void syncTool(tool);
+    if (useBuild.getState().syncing[tool]?.request === request) {
+      setSync(undefined);
+      upsertTask({ id: taskId, title: TITLES[tool], message: null, fraction: 1, done: true });
+      const queued = queuedSyncs.get(tool);
+      const next = queued?.values().next();
+      if (next && !next.done && useBuild.getState().root === root) {
+        queued!.delete(next.value);
+        if (!queued!.size) queuedSyncs.delete(tool);
+        void syncTool(tool, next.value);
+      }
+    }
   }
 }
 
 export function cancelSync(tool: BuildTool) {
+  queuedSyncs.delete(tool);
   const s = useBuild.getState().syncing[tool];
   if (!s) return;
   const taskId = `build-sync:${tool}`;
@@ -419,8 +518,8 @@ export function setCurrentProject(tool: BuildTool, id: string | undefined) {
 export const ANALYZER_KIND = "maven.dependencyAnalyzer";
 
 /**
- * Module the Dependency Analyzer shows: a Maven `pom` (project-relative) or `gradle:<path>`
- * (`gradle::app`) for a Gradle project; `null` = the first one.
+ * Module the Dependency Analyzer shows: a Maven `pom` or a Gradle build/project key;
+ * `null` = the first one.
  */
 export const useAnalyzer = create<{ module: string | null }>(() => ({ module: null }));
 
diff --git a/src/features/database/DataView.tsx b/src/features/database/DataView.tsx
index ec98a55e5..530637f1b 100644
--- a/src/features/database/DataView.tsx
+++ b/src/features/database/DataView.tsx
@@ -4,20 +4,24 @@
  * client-side sorting when the caller does not sort on the server, and the
  * Record / Value / Aggregates side panel following the selection.
  */
-import { useMemo, useState } from "react";
+import { useMemo, useRef, useState, type KeyboardEvent, type RefObject } from "react";
 import clsx from "clsx";
-import { Button, Checkbox, Icon, IconButton, Input, Popup, Select, Tabs, T, type MenuItem } from "@/ui";
+import { Button, Checkbox, Icon, IconButton, Input, Popup, SearchField, Select, Tabs, T, type MenuItem } from "@/ui";
 import { EXPORT_FORMATS, exportData, type ExportData, type ExportFormat } from "./export";
 import { Grid, type GridColumn, type GridProps, type GridRange } from "./Grid";
 import type { Cell } from "./model";
 import {
   aggregates,
+  cellMatcher,
   distinctValues,
+  findCells,
   formatNumber,
+  rowMatches,
   toggleFilterValue,
   visibleRows,
   type LocalFilter,
   type LocalSort,
+  type SearchOptions,
 } from "./resultView";
 import { openDialog } from "./store";
 import { hasLineBreak } from "./cellPreview";
@@ -83,9 +87,23 @@ export interface DataViewProps extends Pick<
   /** The side panel shown (`null`: hidden). */
   panel: DataPanel | null;
   onPanelChange: (panel: DataPanel | null) => void;
+  /** The search bar is shown (the toolbar's search button, ⌘F in the grid). */
+  searchOpen?: boolean;
+  onSearchOpenChange?: (open: boolean) => void;
   "aria-label"?: string;
 }
 
+const NO_SEARCH: SearchOptions = { caseSensitive: false, wholeWord: false, regex: false };
+
+interface SearchState {
+  query: string;
+  options: SearchOptions;
+  /** Show only the rows with a match (IDEA's Filter rows). */
+  filterRows: boolean;
+  /** Index of the current match. */
+  current: number;
+}
+
 export function DataView(props: DataViewProps) {
   const { columns, rowCount, value, fixedRows = rowCount, panel, onPanelChange } = props;
   const columnKey = columns.map((c) => c.name).join("\u0000");
@@ -102,15 +120,49 @@ export function DataView(props: DataViewProps) {
 
   const local = !props.onSort;
   // Display row → loaded row; `null` keeps the identity (no filter, no local sort).
-  const order = useMemo(
+  const shaped = useMemo(
     () =>
       filter.size || (local && localSort)
         ? visibleRows(rowCount, value, filter, local ? localSort : null, fixedRows)
         : null,
     [rowCount, value, filter, local, localSort, fixedRows],
   );
+
+  // Search covers the loaded rows only (the page shown).
+  const { searchOpen = false, onSearchOpenChange } = props;
+  const [search, setSearch] = useState<SearchState>({ query: "", options: NO_SEARCH, filterRows: false, current: 0 });
+  const searchInput = useRef<HTMLInputElement>(null);
+  const matcher = useMemo(
+    () => (searchOpen ? cellMatcher(search.query, search.options) : null),
+    [searchOpen, search.query, search.options],
+  );
+  const test = typeof matcher === "function" ? matcher : null;
+  const order = useMemo(() => {
+    if (!test || !search.filterRows) return shaped;
+    const base = shaped ?? Array.from({ length: rowCount }, (_, i) => i);
+    return base.filter((r) => rowMatches(r, columns.length, value, test));
+  }, [shaped, test, search.filterRows, rowCount, columns.length, value]);
   const at = (r: number) => (order ? order[r]! : r);
   const shown = order ? order.length : rowCount;
+  const matches = useMemo(
+    () => (test ? findCells(order ?? Array.from({ length: rowCount }, (_, i) => i), columns.length, value, test) : []),
+    [test, order, rowCount, columns.length, value],
+  );
+  const matchSet = useMemo(() => new Set(matches.map((m) => `${m.row}:${m.col}`)), [matches]);
+  const currentMatch = matches.length ? matches[Math.min(search.current, matches.length - 1)]! : null;
+  const step = (by: number) =>
+    matches.length &&
+    setSearch((s) => ({
+      ...s,
+      current: (Math.min(s.current, matches.length - 1) + by + matches.length) % matches.length,
+    }));
+  const openSearch = () => {
+    onSearchOpenChange?.(true);
+    requestAnimationFrame(() => {
+      searchInput.current?.focus();
+      searchInput.current?.select();
+    });
+  };
 
   const onSort = local
     ? (column: string) => {
@@ -129,32 +181,50 @@ export function DataView(props: DataViewProps) {
 
   return (
     <div className={styles.dataView}>
-      <div className={clsx(styles.fill, styles.gridHost)}>
-        <Grid
-          aria-label={props["aria-label"]}
-          columns={columns}
-          rowCount={shown}
-          value={(r, c) => value(at(r), c)}
-          rowState={props.rowState && ((r) => props.rowState!(at(r)))}
-          isModified={props.isModified && ((r, c) => props.isModified!(at(r), c))}
-          editable={props.editable}
-          onEdit={props.onEdit && ((r, c, v) => props.onEdit!(at(r), c, v))}
-          sort={sort}
-          onSort={onSort}
-          rowMenu={props.rowMenu && ((rows) => props.rowMenu!(rows.map(at)))}
-          rowNumber={(r) => (props.firstRowNumber ?? 1) + at(r)}
-          onSelectionChange={setRange}
-          onFilter={(col, anchor) => setFilterAt({ col, anchor })}
-          filtered={(col) => filter.has(col)}
-        />
-        {filter.size > 0 && (
-          <div className={styles.filterPill} role="status">
-            {tx`${shown} of ${rowCount} rows`}
-            <button type="button" className={styles.filterPillClear} onClick={() => setFilter(new Map())}>
-              <T>Clear local filter</T>
-            </button>
-          </div>
+      <div className={styles.dataMain}>
+        {searchOpen && (
+          <GridSearchBar
+            inputRef={searchInput}
+            search={search}
+            onChange={(p) => setSearch((s) => ({ ...s, ...p, current: 0 }))}
+            count={matches.length}
+            active={currentMatch ? Math.min(search.current, matches.length - 1) : -1}
+            invalid={matcher === "invalid"}
+            onNext={() => step(1)}
+            onPrevious={() => step(-1)}
+            onClose={() => onSearchOpenChange?.(false)}
+          />
         )}
+        <div className={clsx(styles.fill, styles.gridHost)}>
+          <Grid
+            isMatch={test ? (r, c) => matchSet.has(`${r}:${c}`) : undefined}
+            currentMatch={currentMatch}
+            onFind={onSearchOpenChange && openSearch}
+            aria-label={props["aria-label"]}
+            columns={columns}
+            rowCount={shown}
+            value={(r, c) => value(at(r), c)}
+            rowState={props.rowState && ((r) => props.rowState!(at(r)))}
+            isModified={props.isModified && ((r, c) => props.isModified!(at(r), c))}
+            editable={props.editable}
+            onEdit={props.onEdit && ((r, c, v) => props.onEdit!(at(r), c, v))}
+            sort={sort}
+            onSort={onSort}
+            rowMenu={props.rowMenu && ((rows) => props.rowMenu!(rows.map(at)))}
+            rowNumber={(r) => (props.firstRowNumber ?? 1) + at(r)}
+            onSelectionChange={setRange}
+            onFilter={(col, anchor) => setFilterAt({ col, anchor })}
+            filtered={(col) => filter.has(col)}
+          />
+          {filter.size > 0 && (
+            <div className={styles.filterPill} role="status">
+              {tx`${shown} of ${rowCount} rows`}
+              <button type="button" className={styles.filterPillClear} onClick={() => setFilter(new Map())}>
+                <T>Clear local filter</T>
+              </button>
+            </div>
+          )}
+        </div>
       </div>
       {filterAt && (
         <FilterPopup
@@ -189,6 +259,109 @@ export function DataView(props: DataViewProps) {
   );
 }
 
+/** IDEA's search bar above the grid: Match Case / Words / Regex, n/m, previous / next, Filter rows. */
+function GridSearchBar(props: {
+  inputRef: RefObject<HTMLInputElement | null>;
+  search: SearchState;
+  onChange: (patch: Partial<Omit<SearchState, "current">>) => void;
+  count: number;
+  /** Zero-based current match; -1 when there is none. */
+  active: number;
+  invalid: boolean;
+  onNext: () => void;
+  onPrevious: () => void;
+  onClose: () => void;
+}) {
+  const { search, count, invalid, active, inputRef, onChange, onNext, onPrevious, onClose } = props;
+  const none = !!search.query && !invalid && count === 0;
+  const toggle = (key: keyof SearchOptions) =>
+    onChange({ options: { ...search.options, [key]: !search.options[key] } });
+  const onKeyDown = (e: KeyboardEvent<HTMLDivElement>) => {
+    if (e.key === "Escape") {
+      e.preventDefault();
+      e.stopPropagation();
+      onClose();
+    } else if (e.key === "Enter" || e.key === "F3") {
+      e.preventDefault();
+      if (e.shiftKey) onPrevious();
+      else onNext();
+    } else if (e.altKey && !e.metaKey && !e.ctrlKey) {
+      const key =
+        e.code === "KeyC" ? "caseSensitive" : e.code === "KeyW" ? "wholeWord" : e.code === "KeyX" ? "regex" : null;
+      if (key) {
+        e.preventDefault();
+        toggle(key);
+      }
+    }
+  };
+  return (
+    <div className={styles.gridSearch} role="search" aria-label={tx("Search in results")} onKeyDown={onKeyDown}>
+      <SearchField
+        ref={inputRef}
+        autoFocus
+        className={styles.gridSearchField}
+        value={search.query}
+        onChange={(query) => onChange({ query })}
+        placeholder="Search in results"
+        aria-label="Search in results"
+        invalid={invalid || none}
+        toggles={[
+          {
+            id: "case",
+            icon: "case",
+            title: "Match Case",
+            shortcut: "⌥C",
+            pressed: search.options.caseSensitive,
+            onToggle: () => toggle("caseSensitive"),
+          },
+          {
+            id: "word",
+            icon: "word",
+            title: "Words",
+            shortcut: "⌥W",
+            pressed: search.options.wholeWord,
+            onToggle: () => toggle("wholeWord"),
+          },
+          {
+            id: "regex",
+            icon: "regex",
+            title: "Regex",
+            shortcut: "⌥X",
+            pressed: search.options.regex,
+            onToggle: () => toggle("regex"),
+          },
+        ]}
+      />
+      <span className={clsx(styles.gridSearchCount, (invalid || none) && styles.gridSearchNone)} aria-live="polite">
+        {invalid ? tx("Bad regex") : !search.query ? "" : count === 0 ? tx("0 results") : `${active + 1}/${count}`}
+      </span>
+      <IconButton
+        icon="arrow-up"
+        title="Previous Occurrence"
+        shortcut="⇧↵"
+        size="small"
+        disabled={count === 0}
+        onClick={onPrevious}
+      />
+      <IconButton
+        icon="arrow-down"
+        title="Next Occurrence"
+        shortcut="↵"
+        size="small"
+        disabled={count === 0}
+        onClick={onNext}
+      />
+      <Checkbox
+        checked={search.filterRows}
+        onChange={(filterRows) => onChange({ filterRows })}
+        label={tx("Filter rows")}
+      />
+      <span className={styles.spacer} />
+      <IconButton icon="close" title="Close" shortcut="⎋" size="small" onClick={onClose} />
+    </div>
+  );
+}
+
 function FilterPopup(props: {
   anchor: HTMLElement;
   column: string;
diff --git a/src/features/database/Database.module.css b/src/features/database/Database.module.css
index e8d349d44..599d77da6 100644
--- a/src/features/database/Database.module.css
+++ b/src/features/database/Database.module.css
@@ -560,21 +560,6 @@
 .gridHost {
   position: relative;
 }
-/* IDEA's floating row count at the bottom of a result. */
-.rowPill {
-  position: absolute;
-  left: 50%;
-  bottom: 12px;
-  transform: translateX(-50%);
-  padding: 3px 10px;
-  border: 1px solid var(--border-popup, var(--border));
-  border-radius: var(--radius-small);
-  background: var(--bg-popup, var(--bg-elev));
-  color: var(--fg-secondary);
-  font-size: var(--fs-small);
-  box-shadow: var(--shadow-popup, none);
-  pointer-events: none;
-}
 .resultSource {
   color: var(--fg-muted);
   font-size: var(--fs-small);
@@ -1260,3 +1245,77 @@
   overflow-wrap: anywhere;
   resize: vertical;
 }
+
+/* The grid beside the Record / Value / Aggregates panel, under its search bar. */
+.dataMain {
+  flex: 1;
+  min-width: 0;
+  display: flex;
+  flex-direction: column;
+}
+/* IDEA's search bar above a result grid. */
+.gridSearch {
+  flex: none;
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  padding: 4px 8px;
+  background: var(--bg-elev);
+  border-bottom: 1px solid var(--border);
+  font-size: var(--fs-ui);
+}
+.gridSearchField {
+  flex: 0 1 360px;
+  min-width: 160px;
+}
+.gridSearchCount {
+  font-family: var(--font-mono);
+  font-size: var(--fs-small);
+  color: var(--fg-subtle);
+  padding: 0 6px;
+  white-space: nowrap;
+  min-width: 56px;
+}
+.gridSearchNone {
+  color: var(--danger);
+}
+.cellMatch {
+  background: var(--bg-text-search-result);
+}
+.cellMatchCurrent {
+  background: var(--bg-text-search-result-current);
+}
+
+/* IDEA's floating pager at the bottom of a result: |< < 1-500 of 501+ > >| and the page size. */
+.resultPager {
+  position: absolute;
+  left: 50%;
+  bottom: 12px;
+  transform: translateX(-50%);
+  display: flex;
+  align-items: center;
+  gap: 2px;
+  padding: 2px 4px;
+  border: 1px solid var(--border-popup, var(--border));
+  border-radius: var(--radius-small);
+  background: var(--bg-popup, var(--bg-elev));
+  color: var(--fg-secondary);
+  font-size: var(--fs-small);
+  box-shadow: var(--shadow-popup, none);
+  white-space: nowrap;
+}
+.resultPagerRange {
+  padding: 0 6px;
+}
+.resultPagerCount {
+  padding: 0;
+  border: 0;
+  background: none;
+  color: var(--link);
+  font: inherit;
+  cursor: pointer;
+}
+.resultPagerCount:disabled {
+  color: inherit;
+  cursor: default;
+}
diff --git a/src/features/database/Grid.test.tsx b/src/features/database/Grid.test.tsx
index 3898d1619..78e1742bf 100644
--- a/src/features/database/Grid.test.tsx
+++ b/src/features/database/Grid.test.tsx
@@ -2,6 +2,8 @@ import { installKeyboardDispatcher, useKeymap } from "@/platform/keymap";
 import { registerActions } from "@/platform/actions";
 import { fireEvent, render, screen } from "@testing-library/react";
 import { afterEach, describe, expect, it, vi } from "vitest";
+import { useState } from "react";
+import { DataView } from "./DataView";
 import { Grid } from "./Grid";
 import { CELL_PREVIEW_LIMIT, cellPreview } from "./cellPreview";
 import { exportData } from "./export";
@@ -175,3 +177,60 @@ describe("multi-line database cells", () => {
     expect(onEdit).not.toHaveBeenCalled();
   });
 });
+describe("result grid search", () => {
+  const columns = [
+    { name: "city", type: "text" },
+    { name: "n", type: "int" },
+  ];
+  const data = [
+    ["Shanghai", "1"],
+    ["Beijing", "2"],
+    ["Shenzhen", "3"],
+    ["Hangzhou", "4"],
+  ];
+  const value = (r: number, c: number) => data[r]?.[c] ?? null;
+
+  it("opens the search bar on Ctrl+F and highlights the matches of the page", () => {
+    function Harness() {
+      const [open, setOpen] = useState(false);
+      return (
+        <DataView
+          columns={columns}
+          rowCount={4}
+          value={value}
+          panel={null}
+          onPanelChange={() => {}}
+          searchOpen={open}
+          onSearchOpenChange={setOpen}
+        />
+      );
+    }
+    render(<Harness />);
+    fireEvent.keyDown(screen.getByRole("grid"), { key: "f", ctrlKey: true });
+    const input = screen.getByRole("textbox", { name: "Search in results" });
+    fireEvent.change(input, { target: { value: "sh" } });
+    const marked = () =>
+      screen
+        .getAllByRole("gridcell")
+        .filter((c) => /cellMatch/.test(c.className))
+        .map((c) => c.textContent);
+    expect(marked()).toEqual(["Shanghai", "Shenzhen"]);
+    expect(screen.getByText("1/2")).toBeTruthy();
+    fireEvent.keyDown(input, { key: "Enter" });
+    expect(screen.getByText("2/2")).toBeTruthy();
+
+    // Match Case: "sh" no longer matches "Sh…".
+    fireEvent.click(screen.getByRole("button", { name: /Match Case/ }));
+    expect(marked()).toEqual([]);
+    expect(screen.getByText("0 results")).toBeTruthy();
+    fireEvent.click(screen.getByRole("button", { name: /Match Case/ }));
+
+    // Filter rows keeps only the rows with a match.
+    fireEvent.click(screen.getByRole("checkbox", { name: "Filter rows" }));
+    expect(screen.getAllByRole("row").length - 1).toBe(2);
+
+    fireEvent.keyDown(input, { key: "Escape" });
+    expect(screen.queryByRole("search")).toBeNull();
+    expect(screen.getAllByRole("row").length - 1).toBe(4);
+  });
+});
diff --git a/src/features/database/Grid.tsx b/src/features/database/Grid.tsx
index 6b2f918e0..981020541 100644
--- a/src/features/database/Grid.tsx
+++ b/src/features/database/Grid.tsx
@@ -51,6 +51,12 @@ export interface GridProps {
   /** The header's filter button (IDEA's local filter); `filtered` marks the columns with one. */
   onFilter?: (col: number, anchor: HTMLElement) => void;
   filtered?: (col: number) => boolean;
+  /** Cells matching the search bar's query. */
+  isMatch?: (row: number, col: number) => boolean;
+  /** The search bar's current match: selected and scrolled into view when it changes. */
+  currentMatch?: { row: number; col: number } | null;
+  /** ⌘F / Ctrl+F in the grid (opens the search bar). */
+  onFind?: () => void;
   "aria-label"?: string;
 }
 
@@ -154,6 +160,15 @@ export function Grid(props: GridProps) {
     estimateSize: () => ROW_H,
     overscan: 12,
   });
+  const { currentMatch } = props;
+  useEffect(() => {
+    if (!currentMatch) return;
+    const { row, col } = currentMatch;
+    setSel({ r0: row, c0: col, r1: row, c1: col });
+    virtualizer.scrollToIndex(row, { align: "auto" });
+    // Follows the match only, not the virtualizer's identity.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [currentMatch?.row, currentMatch?.col]);
   const totalWidth = useMemo(() => NUM_W + widths.reduce((a, b) => a + b, 0), [widths]);
   const template = `${NUM_W}px ${widths.map((w) => `${w}px`).join(" ")}`;
 
@@ -211,6 +226,11 @@ export function Grid(props: GridProps) {
       copy("tsv", false);
       return;
     }
+    if (mod && e.key.toLowerCase() === "f" && props.onFind) {
+      e.preventDefault();
+      props.onFind();
+      return;
+    }
     if (mod && e.key.toLowerCase() === "a") {
       e.preventDefault();
       if (rowCount && columns.length) setSel({ r0: 0, c0: 0, r1: rowCount - 1, c1: columns.length - 1 });
@@ -466,6 +486,8 @@ export function Grid(props: GridProps) {
                     className={clsx(
                       styles.cell,
                       numeric[c] && styles.cellNumber,
+                      props.isMatch?.(r, c) && styles.cellMatch,
+                      currentMatch?.row === r && currentMatch.col === c && styles.cellMatchCurrent,
                       selected(r, c) && styles.cellSelected,
                       props.isModified?.(r, c) && styles.cellModified,
                     )}
diff --git a/src/features/database/ResultsView.tsx b/src/features/database/ResultsView.tsx
index 9cd40b564..ee3d34ddc 100644
--- a/src/features/database/ResultsView.tsx
+++ b/src/features/database/ResultsView.tsx
@@ -7,16 +7,22 @@ import { copySelectionOnKeyDown } from "@/ui/selectableText";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import clsx from "clsx";
 import type { DbPlanNode } from "@/platform/ipc";
-import { EmptyState, Icon, IconButton, Spinner, Tabs, Tree, showContextMenu, T } from "@/ui";
+import { shortcutLabel } from "@/platform/keymap";
+import { EmptyState, Icon, IconButton, Select, Spinner, Tabs, Tree, showContextMenu, T } from "@/ui";
 import { ChartView } from "./ChartView";
 import { DataView, ExtractorSelect, PanelToggle, exportMenu, type DataPanel } from "./DataView";
 import type { ExportData, ExportFormat } from "./export";
+import { pageWindow } from "./resultView";
 import { analyze } from "./sql/analyze";
 import {
   OUTPUT_TAB,
   clearOutput,
   closeResult,
+  countResult,
+  countable,
+  loadResultPage,
   outcomeSummary,
+  pageable,
   rerunResult,
   sourceById,
   targetLabel,
@@ -72,9 +78,88 @@ function queryTable(text: string, data: Pick<ExportData, "driver">): string {
   return a.refs.find((r) => r.depth === 0 && r.kind === "table")?.name ?? "MY_TABLE";
 }
 
+const PAGE_SIZES = [10, 100, 500, 1000];
+
+/** IDEA's pager at the bottom of a result: |< < 1-500 of 501+ > >| and the page size; paging runs the query again. */
+function Pager({ tab }: { tab: ResultTab }) {
+  const r = tab.outcome.result!;
+  const page = tab.page ?? 0;
+  const pageSize = tab.pageSize ?? Math.max(r.rows.length, 1);
+  const state = { page, pageSize, rows: r.rows.length, hasMore: r.hasMore, total: tab.total ?? null };
+  const w = pageWindow(state);
+  const canPage = pageable(tab) && !tab.busy;
+  const go = (p: number, size = pageSize) => void loadResultPage(tab.id, p, size);
+  const goLast = async () => {
+    let lastPage = w.lastPage;
+    if (lastPage === null) {
+      const total = await countResult(tab.id);
+      if (total === null) return;
+      lastPage = pageWindow({ ...state, total }).lastPage;
+    }
+    if (lastPage !== null && lastPage !== page) go(lastPage);
+  };
+  const { first, last } = w;
+  const total = w.total === null ? `${w.last + 1}+` : String(w.total);
+  const sizes = PAGE_SIZES.includes(pageSize) ? PAGE_SIZES : [...PAGE_SIZES, pageSize].sort((a, b) => a - b);
+  return (
+    <div
+      className={styles.resultPager}
+      role="toolbar"
+      aria-label={tx("Result pages")}
+      title={outcomeSummary(tab.outcome)}
+    >
+      <IconButton
+        icon="page-first"
+        title="First Page"
+        size="small"
+        disabled={!canPage || page === 0}
+        onClick={() => go(0)}
+      />
+      <IconButton
+        icon="chevron-left"
+        title="Previous Page"
+        size="small"
+        disabled={!canPage || page === 0}
+        onClick={() => go(page - 1)}
+      />
+      <button
+        type="button"
+        className={clsx(styles.resultPagerRange, styles.resultPagerCount)}
+        disabled={w.total !== null || !canPage || !countable(tab)}
+        title={w.total === null ? tx("Count rows") : undefined}
+        onClick={() => void countResult(tab.id)}
+      >
+        {tx`${first}-${last} of ${total}`}
+      </button>
+      <IconButton
+        icon="chevron-right"
+        title="Next Page"
+        size="small"
+        disabled={!canPage || !r.hasMore}
+        onClick={() => go(page + 1)}
+      />
+      <IconButton
+        icon="page-last"
+        title="Last Page"
+        size="small"
+        disabled={!canPage || (!r.hasMore && w.total !== null) || (w.total === null && !countable(tab))}
+        onClick={() => void goLast()}
+      />
+      <Select
+        aria-label="Page size"
+        value={String(pageSize)}
+        options={sizes.map((v) => ({ value: String(v), label: String(v) }))}
+        onChange={(v) => go(0, Number(v))}
+        disabled={!canPage}
+      />
+    </div>
+  );
+}
+
 function Result({ tab }: { tab: ResultTab }) {
   const [view, setView] = useState<"table" | "chart">("table");
   const [panel, setPanel] = useState<DataPanel | null>(null);
+  const [searchOpen, setSearchOpen] = useState(false);
   const [extractor, setExtractor] = useState<ExportFormat>("csv");
   const r = tab.outcome.result;
   const columns = useMemo(() => (r ? r.columns.map((c) => ({ name: c.name, type: c.typeName })) : []), [r]);
@@ -94,6 +179,15 @@ function Result({ tab }: { tab: ResultTab }) {
         <IconButton icon="db-chart" title="Chart" aria-pressed={view === "chart"} onClick={() => setView("chart")} />
         <span className={styles.toolbarSeparator} />
         <IconButton icon="refresh" title="Rerun Query" disabled={tab.busy} onClick={() => void rerunResult(tab.id)} />
+        {view === "table" && (
+          <IconButton
+            icon="search"
+            title="Search"
+            shortcut={shortcutLabel("find.inFile")}
+            aria-pressed={searchOpen}
+            onClick={() => setSearchOpen(!searchOpen)}
+          />
+        )}
         {tab.busy && <Spinner size={12} />}
         <span className={styles.spacer} />
         <span className={styles.resultSource} title={tab.outcome.statement.text}>
@@ -121,12 +215,12 @@ function Result({ tab }: { tab: ResultTab }) {
             value={value}
             panel={panel}
             onPanelChange={setPanel}
+            searchOpen={searchOpen}
+            onSearchOpenChange={setSearchOpen}
+            firstRowNumber={(tab.page ?? 0) * (tab.pageSize ?? 0) + 1}
             aria-label={tab.title}
           />
-          <div className={styles.rowPill} role="status" title={outcomeSummary(tab.outcome)}>
-            {r.rows.length === 1 ? tx`${r.rows.length} row` : tx`${r.rows.length} rows`}
-            {r.hasMore ? ` ${tx("(limit reached)")}` : ""}
-          </div>
+          <Pager tab={tab} />
         </div>
       )}
     </div>
diff --git a/src/features/database/TableEditor.tsx b/src/features/database/TableEditor.tsx
index 599456844..d188963d1 100644
--- a/src/features/database/TableEditor.tsx
+++ b/src/features/database/TableEditor.tsx
@@ -31,6 +31,7 @@ import { openDialog, sourceById, withConnection } from "./store";
 import type { TableRef } from "./tableInput";
 import styles from "./Database.module.css";
 import { tx } from "@/platform/i18n";
+import { shortcutLabel } from "@/platform/keymap";
 
 const PAGE_SIZES = ["100", "500", "1000", "5000"];
 
@@ -46,6 +47,7 @@ export function TableEditor({ input }: { input: EditorInput }) {
   const [nonce, setNonce] = useState(0);
   const [edits, setEdits] = useState<PendingEdits>(emptyEdits);
   const [panel, setPanel] = useState<DataPanel | null>(null);
+  const [searchOpen, setSearchOpen] = useState(false);
   const [extractor, setExtractor] = useState<ExportFormat>("csv");
   // The ORDER BY field while it's being edited; it shows the sort otherwise.
   const [orderDraft, setOrderDraft] = useState<string | null>(null);
@@ -254,6 +256,13 @@ export function TableEditor({ input }: { input: EditorInput }) {
           disabled={!editable}
           onClick={() => openDialog({ kind: "import", id: ref.id, schema: ref.schema, table: ref.table })}
         />
+        <IconButton
+          icon="search"
+          title="Search"
+          shortcut={shortcutLabel("find.inFile")}
+          aria-pressed={searchOpen}
+          onClick={() => setSearchOpen(!searchOpen)}
+        />
         <PanelToggle panel={panel} onChange={setPanel} />
       </div>
       <div className={styles.filterBar}>
@@ -322,6 +331,8 @@ export function TableEditor({ input }: { input: EditorInput }) {
             value={value}
             panel={panel}
             onPanelChange={setPanel}
+            searchOpen={searchOpen}
+            onSearchOpenChange={setSearchOpen}
             firstRowNumber={offset + 1}
             rowState={(r) => (r >= loaded ? "inserted" : edits.deletes.has(r) ? "deleted" : null)}
             isModified={(r, c) => !!edits.updates.get(r)?.has(names[c]!)}
diff --git a/src/features/database/resultView.test.ts b/src/features/database/resultView.test.ts
index 79d297eff..8ad3dc5d2 100644
--- a/src/features/database/resultView.test.ts
+++ b/src/features/database/resultView.test.ts
@@ -12,6 +12,10 @@ import {
 import { dropSql } from "./objects";
 import {
   aggregates,
+  cellMatcher,
+  findCells,
+  pageFetch,
+  pageWindow,
   chartSeries,
   compareCells,
   distinctValues,
@@ -219,3 +223,81 @@ describe("dropping schema objects", () => {
     );
   });
 });
+
+describe("grid search", () => {
+  const opts = { caseSensitive: false, wholeWord: false, regex: false };
+
+  it("matches cell text with Match Case, Words and Regex", () => {
+    const m = cellMatcher("shang", opts);
+    expect(typeof m).toBe("function");
+    const test = m as (v: string) => boolean;
+    expect(test("Shanghai")).toBe(true);
+    expect(test("Beijing")).toBe(false);
+    expect((cellMatcher("shang", { ...opts, caseSensitive: true }) as (v: string) => boolean)("Shanghai")).toBe(false);
+    const word = cellMatcher("23", { ...opts, wholeWord: true }) as (v: string) => boolean;
+    expect(word("23")).toBe(true);
+    expect(word("123")).toBe(false);
+    expect(word("a 23 b")).toBe(true);
+    const re = cellMatcher(String.raw`^\d\.\d$`, { ...opts, regex: true }) as (v: string) => boolean;
+    expect(re("2.5")).toBe(true);
+    expect(re("10")).toBe(false);
+    // A dot is literal without Regex.
+    expect((cellMatcher("2.5", opts) as (v: string) => boolean)("215")).toBe(false);
+  });
+
+  it("reports no query and a bad regex", () => {
+    expect(cellMatcher("", opts)).toBeNull();
+    expect(cellMatcher("(", { ...opts, regex: true })).toBe("invalid");
+  });
+
+  it("steps over astral characters on empty matches in Words mode", () => {
+    for (const query of ["x*", "|", "^", String.raw`\d*`, String.raw`\b`]) {
+      const m = cellMatcher(query, { ...opts, regex: true, wholeWord: true }) as (v: string) => boolean;
+      expect(() => m("a😀b")).not.toThrow();
+      expect(typeof m("😀")).toBe("boolean");
+    }
+  });
+
+  it("finds the matching cells row by row, skipping NULL", () => {
+    const m = cellMatcher("i", opts) as (v: string) => boolean;
+    expect(findCells([0, 1, 2, 3], 3, value, m)).toEqual([
+      { row: 0, col: 1 },
+      { row: 1, col: 1 },
+      { row: 2, col: 1 },
+    ]);
+    // Display rows are positions in `rows`.
+    expect(findCells([3, 1], 3, value, m)).toEqual([{ row: 1, col: 1 }]);
+  });
+});
+
+describe("result pages", () => {
+  it("describes the rows of a page, IDEA style", () => {
+    expect(pageWindow({ page: 0, pageSize: 500, rows: 500, hasMore: true, total: null })).toEqual({
+      first: 1,
+      last: 500,
+      total: null,
+      lastPage: null,
+    });
+    expect(pageWindow({ page: 1, pageSize: 500, rows: 1, hasMore: false, total: null })).toEqual({
+      first: 501,
+      last: 501,
+      total: 501,
+      lastPage: 1,
+    });
+    expect(pageWindow({ page: 0, pageSize: 100, rows: 100, hasMore: true, total: 1234 })).toMatchObject({
+      total: 1234,
+      lastPage: 12,
+    });
+    expect(pageWindow({ page: 0, pageSize: 100, rows: 0, hasMore: false, total: null })).toEqual({
+      first: 0,
+      last: 0,
+      total: 0,
+      lastPage: 0,
+    });
+  });
+
+  it("slices the rows of a page from a fetch of every row up to it", () => {
+    expect(pageFetch(0, 500)).toEqual({ maxRows: 500, skip: 0 });
+    expect(pageFetch(2, 100)).toEqual({ maxRows: 100, skip: 200 });
+  });
+});
diff --git a/src/features/database/resultView.ts b/src/features/database/resultView.ts
index 5c8cb588c..088735fb0 100644
--- a/src/features/database/resultView.ts
+++ b/src/features/database/resultView.ts
@@ -1,6 +1,7 @@
 /**
  * Pure helpers of the result views: IDEA's local filter and client-side sort
- * of loaded rows, the Aggregates of a selection, and the series of the chart.
+ * of loaded rows, search in the grid, paging of console results, the
+ * Aggregates of a selection, and the series of the chart.
  */
 import type { Cell } from "./model";
 
@@ -192,3 +193,114 @@ export function niceTicks(min: number, max: number, count = 5): number[] {
   if (out.at(-1)! < hi) out.push(Number((out.at(-1)! + step).toPrecision(12)));
   return out;
 }
+
+/** IDEA's search options of the grid's search bar. */
+export interface SearchOptions {
+  caseSensitive: boolean;
+  wholeWord: boolean;
+  regex: boolean;
+}
+
+const REGEX_SPECIALS = /[.*+?^${}()|[\]\\]/g;
+const WORD_CHAR = /[\p{L}\p{N}_$]/u;
+
+/** A test of a cell's text against `query`; `null` without a query, `"invalid"` for a bad regex. */
+export function cellMatcher(query: string, options: SearchOptions): ((text: string) => boolean) | null | "invalid" {
+  if (!query) return null;
+  const source = options.regex ? query : query.replace(REGEX_SPECIALS, "\\$&");
+  let re: RegExp;
+  try {
+    re = new RegExp(source, options.caseSensitive ? "gu" : "giu");
+  } catch {
+    return "invalid";
+  }
+  // Words: a match with no word character on either side (no lookbehind: older WebKit lacks it).
+  return (text) => {
+    re.lastIndex = 0;
+    let m: RegExpExecArray | null;
+    while ((m = re.exec(text))) {
+      const start = m.index;
+      const end = start + m[0].length;
+      if (end === start) {
+        // Step a whole code point: with the `u` flag a lastIndex inside a surrogate pair
+        // snaps back to the pair's start, which would match the same empty string forever.
+        re.lastIndex = start + ((text.codePointAt(start) ?? 0) > 0xffff ? 2 : 1);
+        if (!options.wholeWord) return true;
+        continue;
+      }
+      if (!options.wholeWord || (!WORD_CHAR.test(text[start - 1] ?? "") && !WORD_CHAR.test(text[end] ?? "")))
+        return true;
+    }
+    return false;
+  };
+}
+
+/** The cells matching `test`, row by row; `row` is the position in `rows` (display order). NULL never matches. */
+export function findCells(
+  rows: readonly number[],
+  colCount: number,
+  value: (row: number, col: number) => Cell,
+  test: (text: string) => boolean,
+): Array<{ row: number; col: number }> {
+  const out: Array<{ row: number; col: number }> = [];
+  rows.forEach((r, row) => {
+    for (let col = 0; col < colCount; col++) {
+      const v = value(r, col);
+      if (v !== null && test(v)) out.push({ row, col });
+    }
+  });
+  return out;
+}
+
+/** Whether any cell of loaded row `r` matches `test`. */
+export function rowMatches(
+  r: number,
+  colCount: number,
+  value: (row: number, col: number) => Cell,
+  test: (text: string) => boolean,
+): boolean {
+  for (let col = 0; col < colCount; col++) {
+    const v = value(r, col);
+    if (v !== null && test(v)) return true;
+  }
+  return false;
+}
+
+export interface PageState {
+  /** Zero-based page shown. */
+  page: number;
+  pageSize: number;
+  /** Rows on the page. */
+  rows: number;
+  /** More rows follow the page. */
+  hasMore: boolean;
+  /** Counted rows of the whole query, when known. */
+  total: number | null;
+}
+
+export interface PageWindow {
+  /** One-based numbers of the first and last row shown (0 and 0 on an empty page). */
+  first: number;
+  last: number;
+  /** Rows of the whole query: known once counted or on reaching the end. */
+  total: number | null;
+  /** Zero-based last page, when the total is known. */
+  lastPage: number | null;
+}
+
+/** What the pager shows ("1-500 of 501+"). */
+export function pageWindow({ page, pageSize, rows, hasMore, total }: PageState): PageWindow {
+  const offset = page * pageSize;
+  const known = total ?? (hasMore ? null : offset + rows);
+  return {
+    first: rows ? offset + 1 : 0,
+    last: offset + rows,
+    total: known,
+    lastPage: known === null ? null : Math.max(0, Math.ceil(known / pageSize) - 1),
+  };
+}
+
+/** A page is read by running the query again: the backend reads past the rows before it and returns only the page. */
+export function pageFetch(page: number, pageSize: number): { maxRows: number; skip: number } {
+  return { maxRows: pageSize, skip: page * pageSize };
+}
diff --git a/src/features/database/sql/readOnly.test.ts b/src/features/database/sql/readOnly.test.ts
new file mode 100644
index 000000000..dcc3f4584
--- /dev/null
+++ b/src/features/database/sql/readOnly.test.ts
@@ -0,0 +1,28 @@
+import { describe, expect, it } from "vitest";
+import { isReadOnlyQuery } from "./readOnly";
+
+describe("isReadOnlyQuery", () => {
+  it("accepts queries that only read", () => {
+    for (const text of [
+      "SELECT * FROM t",
+      "with x as (select 1) select * from x",
+      "VALUES (1), (2)",
+      "show tables",
+      "(select 1) union (select 2)",
+    ])
+      expect(isReadOnlyQuery(text, "postgres"), text).toBe(true);
+  });
+
+  it("rejects statements that change data", () => {
+    for (const text of [
+      "DELETE FROM t RETURNING *",
+      "UPDATE t SET a = 1 RETURNING a",
+      "INSERT INTO t VALUES (1) RETURNING id",
+      "with d as (delete from t returning *) select * from d",
+      "select * into t2 from t",
+      "select * from t for update",
+      "select nextval('s')",
+    ])
+      expect(isReadOnlyQuery(text, "postgres"), text).toBe(false);
+  });
+});
diff --git a/src/features/database/sql/readOnly.ts b/src/features/database/sql/readOnly.ts
new file mode 100644
index 000000000..6feb350bf
--- /dev/null
+++ b/src/features/database/sql/readOnly.ts
@@ -0,0 +1,15 @@
+import type { DbDriver } from "@/platform/ipc";
+import { lex } from "./lexer";
+
+/** Statements that only read. */
+const READ_VERBS = new Set(["SELECT", "WITH", "VALUES", "TABLE", "SHOW", "DESCRIBE", "DESC", "EXPLAIN", "PRAGMA"]);
+/** Words that make a reading statement write (data-modifying CTEs, SELECT INTO, row locks, sequences). */
+const WRITES = new Set(["INSERT", "UPDATE", "DELETE", "MERGE", "INTO", "NEXTVAL", "SETVAL", "CALL", "EXEC", "EXECUTE"]);
+
+/** Whether running `text` again only reads (paging a result re-runs its query). */
+export function isReadOnlyQuery(text: string, driver: DbDriver): boolean {
+  const tokens = lex(text, driver).tokens;
+  const first = tokens.find((t) => t.text !== "(");
+  if (!first || first.kind !== "word" || !READ_VERBS.has(first.upper)) return false;
+  return !tokens.some((t) => t.kind === "word" && WRITES.has(t.upper));
+}
diff --git a/src/features/database/store.ts b/src/features/database/store.ts
index e5e133170..038646894 100644
--- a/src/features/database/store.ts
+++ b/src/features/database/store.ts
@@ -39,6 +39,8 @@ import type { ExportData, ExportFormat } from "./export";
 import type { DbObjectRef } from "./objects";
 import { formatted } from "./sql/format";
 import { bindParams, findParams } from "./sql/params";
+import { isReadOnlyQuery } from "./sql/readOnly";
+import { pageFetch } from "./resultView";
 import { tx } from "@/platform/i18n";
 
 export const DB_TOOL_WINDOW = "database";
@@ -58,6 +60,11 @@ export interface ResultTab {
   plan?: DbPlanNode[];
   /** Being re-run. */
   busy?: boolean;
+  /** Zero-based page of the result shown in `outcome` (IDEA's paging re-runs the query). */
+  page?: number;
+  pageSize?: number;
+  /** Rows of the whole query, once counted. */
+  total?: number | null;
 }
 
 /** One line of the consoles' Output log (IDEA's Database Console output). */
@@ -643,12 +650,19 @@ function promptOf(id: string): string {
   return useDatabase.getState().completion[id]?.defaultSchema || sourceById(id)?.name || id;
 }
 
-/** Runs `statements` on `id`, logging to Output; errors stop the batch (backend). */
-async function run(id: string, statements: SqlStatement[], request: RequestId): Promise<DbStatementOutcome[]> {
+/**
+ * Runs `statements` on `id`, logging to Output; errors stop the batch (backend).
+ * Results keep `maxRows` rows after the first `skip`, which the backend reads past.
+ */
+async function run(
+  id: string,
+  statements: SqlStatement[],
+  request: RequestId,
+  maxRows = useDatabase.getState().maxRows,
+  skip = 0,
+): Promise<DbStatementOutcome[]> {
   const wasConnected = useDatabase.getState().connected.has(id);
-  const outcomes = await withConnection(id, () =>
-    call(commands.dbExecute(request, id, statements, useDatabase.getState().maxRows)),
-  );
+  const outcomes = await withConnection(id, () => call(commands.dbExecute(request, id, statements, skip, maxRows)));
   if (!wasConnected) log("info", "Connected");
   for (const o of outcomes) {
     log("statement", o.statement.text, `${promptOf(id)}>`);
@@ -791,12 +805,13 @@ export async function executeConsole(
   const request = nextRequestId();
   useDatabase.setState((s) => ({ running: { ...s.running, [path]: request } }));
   try {
-    const outcomes = await run(id, statements, request);
+    const pageSize = useDatabase.getState().maxRows;
+    const outcomes = await run(id, statements, request, pageSize);
     const tabs: ResultTab[] = outcomes
       .filter((o) => o.result?.columns.length)
       .map((outcome) => {
         const n = nextTab++;
-        return { id: n, title: tx`Result ${n}`, path, sourceId: id, outcome };
+        return { id: n, title: tx`Result ${n}`, path, sourceId: id, outcome, page: 0, pageSize };
       });
     const failed = outcomes.some((o) => o.error);
     useDatabase.setState((s) => ({
@@ -912,28 +927,90 @@ export async function openObjectDdl(id: string, schema: string, kind: DbObjectKi
 export async function rerunResult(tabId: number): Promise<void> {
   const tab = useDatabase.getState().results.find((r) => r.id === tabId);
   if (!tab || tab.busy) return;
-  const patch = (p: Partial<ResultTab>) =>
-    useDatabase.setState((s) => ({ results: s.results.map((r) => (r.id === tabId ? { ...r, ...p } : r)) }));
-  patch({ busy: true });
   if (tab.plan) {
+    patchResult(tabId, { busy: true });
     try {
-      patch({ plan: await explain(tab.sourceId, tab.outcome.statement), busy: false });
+      patchResult(tabId, { plan: await explain(tab.sourceId, tab.outcome.statement), busy: false });
     } catch (e) {
-      patch({ busy: false });
+      patchResult(tabId, { busy: false });
       if (!isCancelled(e)) log("error", `[${targetLabel(tab.sourceId)}] ${message(e)}`);
     }
     return;
   }
+  await loadResultPage(tabId, tab.page ?? 0, tab.pageSize ?? useDatabase.getState().maxRows, true);
+}
+
+/** Whether result tab `tab` can show other pages: running its query again only reads. */
+export function pageable(tab: ResultTab): boolean {
+  return !tab.plan && isReadOnlyQuery(tab.outcome.statement.text, sourceById(tab.sourceId)?.driver ?? "sqlite");
+}
+
+function patchResult(tabId: number, p: Partial<ResultTab>) {
+  useDatabase.setState((s) => ({ results: s.results.map((r) => (r.id === tabId ? { ...r, ...p } : r)) }));
+}
+
+/**
+ * Shows page `page` of `pageSize` rows of result tab `tabId`: its query runs
+ * again and the backend returns only that page (IDEA's result paging).
+ * `rerun` also forgets the counted total.
+ */
+export async function loadResultPage(tabId: number, page: number, pageSize: number, rerun = false): Promise<void> {
+  const tab = useDatabase.getState().results.find((r) => r.id === tabId);
+  if (!tab || tab.busy || tab.plan) return;
+  if (page > 0 && !pageable(tab)) return;
+  patchResult(tabId, { busy: true });
+  const { maxRows, skip } = pageFetch(page, pageSize);
   try {
-    const [outcome] = await run(tab.sourceId, [tab.outcome.statement], nextRequestId());
-    patch(outcome?.result ? { outcome, busy: false } : { busy: false });
+    const [outcome] = await run(tab.sourceId, [tab.outcome.statement], nextRequestId(), maxRows, skip);
+    const r = outcome?.result;
+    if (r) {
+      const sizeChanged = pageSize !== tab.pageSize;
+      patchResult(tabId, {
+        outcome,
+        page,
+        pageSize,
+        busy: false,
+        ...(rerun || sizeChanged ? { total: null } : {}),
+      });
+    } else patchResult(tabId, { busy: false });
     if (outcome?.error) useDatabase.setState({ activeResult: OUTPUT_TAB });
   } catch (e) {
-    patch({ busy: false });
+    patchResult(tabId, { busy: false });
     if (!isCancelled(e)) log("error", message(e));
   }
 }
 
+/** `SELECT COUNT(*)` over a query, for queries that can be a subquery. */
+function countQuery(text: string): string | null {
+  if (!/^\s*(\(|select\b|with\b|values\b|table\b)/i.test(text)) return null;
+  // `)` on its own line: a trailing line comment (`… from t -- note`) would swallow it.
+  return `select count(*) from (\n${text.trim()}\n) q`;
+}
+
+/** Whether the rows of result tab `tab` can be counted. */
+export function countable(tab: ResultTab): boolean {
+  return pageable(tab) && countQuery(tab.outcome.statement.text) !== null;
+}
+
+/** Counts the rows of result tab `tabId`'s whole query (the pager's "of 501+"). */
+export async function countResult(tabId: number): Promise<number | null> {
+  const tab = useDatabase.getState().results.find((r) => r.id === tabId);
+  if (!tab || tab.busy || !countable(tab)) return null;
+  const text = countQuery(tab.outcome.statement.text)!;
+  patchResult(tabId, { busy: true });
+  try {
+    const [outcome] = await run(tab.sourceId, [{ from: 0, to: text.length, text }], nextRequestId(), 1);
+    const total = Number(outcome?.result?.rows[0]?.[0]);
+    const known = outcome?.error || !Number.isFinite(total) ? null : total;
+    patchResult(tabId, { busy: false, ...(known === null ? {} : { total: known }) });
+    return known;
+  } catch (e) {
+    patchResult(tabId, { busy: false });
+    if (!isCancelled(e)) log("error", message(e));
+    return null;
+  }
+}
+
 /** Statements that only read (they leave a manual transaction clean). */
 const READS = /^\s*(select|show|pragma|explain|describe|desc|values|table)\b/i;
 
diff --git a/src/features/debugger/__tests__/toolWindow.test.tsx b/src/features/debugger/__tests__/toolWindow.test.tsx
index 214484166..405badeff 100644
--- a/src/features/debugger/__tests__/toolWindow.test.tsx
+++ b/src/features/debugger/__tests__/toolWindow.test.tsx
@@ -25,6 +25,9 @@ vi.mock("@/platform/ipc", async (importOriginal) => {
   };
 });
 
+const confirmTerminate = vi.hoisted(() => vi.fn(async () => false));
+vi.mock("@/workbench/confirmTerminate", () => ({ confirmTerminate }));
+
 import { useDebug, type DebugSession } from "../state";
 import { DebugTabs, DebugToolWindow } from "../ui/DebugToolWindow";
 
@@ -49,6 +52,17 @@ const session: DebugSession = {
 };
 
 describe("debug tool window", () => {
+  it("offers Hot Reload and Hot Restart for Dart and Flutter sessions only", () => {
+    const hot = () => ["debug.hotReload", "debug.hotRestart"].map((name) => !!screen.queryByRole("button", { name }));
+    useDebug.setState({ sessions: { 1: { ...session, status: "running" } }, active: 1 });
+    const { unmount } = render(<DebugToolWindow />);
+    expect(hot()).toEqual([false, false]);
+    unmount();
+    useDebug.setState({ sessions: { 1: { ...session, adapter: "dart", status: "running" } }, active: 1 });
+    render(<DebugToolWindow />);
+    expect(hot()).toEqual([true, true]);
+  });
+
   it("shows preparation output, preserves a chosen tab and opens variables on pause", () => {
     useDebug.setState({ sessions: { 1: { ...session, status: "starting" } }, active: 1 });
     render(<DebugToolWindow />);
@@ -82,4 +96,49 @@ describe("debug tool window", () => {
     // A multi-line rendering stays on its row.
     expect(screen.getByText(/dtype: object/).textContent).toBe("high    7.86 low     7.66 Name: 772, dtype: object");
   });
+
+  it("closes a session tab and moves the selection to the one left", async () => {
+    useDebug.setState({
+      sessions: {
+        1: { ...session, status: "terminated" },
+        2: { ...session, id: 2, name: "app", status: "terminated" },
+      },
+      active: 1,
+    });
+    render(<DebugTabs />);
+    await act(async () => fireEvent.click(screen.getAllByRole("button", { name: "Close Tab" })[0]!));
+    expect(screen.getAllByRole("tab").map((tab) => tab.textContent)).toEqual(["app"]);
+    expect(useDebug.getState().active).toBe(2);
+    expect(useDebug.getState().sessions).not.toHaveProperty("1");
+  });
+
+  it("passes the selection of a closed tab to the tab on its left", async () => {
+    useDebug.setState({
+      sessions: {
+        4: { ...session, id: 4, name: "a", status: "terminated" },
+        5: { ...session, id: 5, name: "b", status: "terminated" },
+        6: { ...session, id: 6, name: "c", status: "terminated" },
+      },
+      active: 5,
+    });
+    render(<DebugTabs />);
+    await act(async () => fireEvent.click(screen.getAllByRole("button", { name: "Close Tab" })[1]!));
+    expect(useDebug.getState().active).toBe(4);
+  });
+
+  it("keeps a live session when the user doesn't terminate it", async () => {
+    useDebug.setState({ sessions: { 8: { ...session, id: 8, name: "server" } }, active: 8 });
+    render(<DebugTabs />);
+    await act(async () => fireEvent.click(screen.getAllByRole("button", { name: "Close Tab" })[0]!));
+    expect(confirmTerminate).toHaveBeenCalledWith("server");
+    expect(useDebug.getState().sessions).toHaveProperty("8");
+  });
+
+  it("leaves nothing selected once the last tab is closed", async () => {
+    useDebug.setState({ sessions: { 3: { ...session, id: 3, status: "terminated" } }, active: 3 });
+    render(<DebugTabs />);
+    await act(async () => fireEvent.click(screen.getAllByRole("button", { name: "Close Tab" })[0]!));
+    expect(useDebug.getState().active).toBeNull();
+    expect(useDebug.getState().sessions).toEqual({});
+  });
 });
diff --git a/src/features/debugger/actions.ts b/src/features/debugger/actions.ts
index 381f291ca..759c6fe3c 100644
--- a/src/features/debugger/actions.ts
+++ b/src/features/debugger/actions.ts
@@ -436,6 +436,30 @@ export function registerDebugActions(): () => void {
         await report(tx("Pause failed"), call(commands.debugPause(s.id, thread)));
       },
     },
+    {
+      id: "debug.hotReload",
+      title: "Hot Reload",
+      category: "Debug",
+      icon: "hot-reload",
+      description: "Flutter: inject the changed sources into the running app",
+      when: "debugSessionRunning && debugSessionDart",
+      run: () => {
+        const s = activeSession();
+        if (s) void report("Hot Reload failed", call(commands.debugHotReload(s.id)));
+      },
+    },
+    {
+      id: "debug.hotRestart",
+      title: "Hot Restart",
+      category: "Debug",
+      icon: "refresh",
+      description: "Flutter: restart the app, discarding its state",
+      when: "debugSessionRunning && debugSessionDart",
+      run: () => {
+        const s = activeSession();
+        if (s) void report("Hot Restart failed", call(commands.debugHotRestart(s.id)));
+      },
+    },
     step("debug.stepOver", "Step Over", "over", "step-over"),
     step("debug.stepInto", "Step Into", "into", "step-into"),
     step("debug.stepOut", "Step Out", "out", "step-out"),
diff --git a/src/features/debugger/launch.ts b/src/features/debugger/launch.ts
index a7b667745..1137cdd65 100644
--- a/src/features/debugger/launch.ts
+++ b/src/features/debugger/launch.ts
@@ -313,6 +313,49 @@ function nativeLaunch(rc: RunConfig, cwd: string, adapter: string): LaunchConfig
   return out;
 }
 
+/**
+ * Flutter: `flutter debug_adapter` starts the tool itself, so `program` is the
+ * entry point (`lib/main.dart`) — never the interpreter named by `command`.
+ */
+function flutterLaunch(rc: RunConfig, cwd: string, adapter: string): LaunchConfig {
+  // A file-scoped config carries the entry point as its last `.dart` argument
+  // (`dart run lib/main.dart`); a user config may name none, which is the
+  // conventional Flutter entry point.
+  const entry = [...rc.args].reverse().find((a) => a.endsWith(".dart")) ?? "lib/main.dart";
+  return {
+    ...base(rc, adapter, cwd),
+    program: join(cwd, entry),
+  };
+}
+
+/**
+ * Flutter add-to-app: the host app is built and installed by its own Gradle
+ * build, so the debugger attaches to the already running app instead of
+ * launching `lib/main.dart` (which would build the module on its own).
+ *
+ * `params.vm-service-uri` pins the VM Service endpoint (`flutter attach
+ * --debug-uri`); without it `flutter attach` discovers the running app on the
+ * device. `params.device` becomes `-d <device>`.
+ */
+function flutterAttach(rc: RunConfig, cwd: string, adapter: string): LaunchConfig {
+  const p = rc.params ?? {};
+  const uri = p["vm-service-uri"] || p.vmServiceUri;
+  const device = p.device;
+  // `__flutter` tells the adapter launcher to use `flutter debug_adapter`
+  // whatever the working directory holds (an add-to-app module lives below a
+  // workspace root that has no Flutter dependency of its own). It is removed
+  // before the request reaches the adapter.
+  const extra: Record<string, unknown> = { __flutter: true };
+  if (uri) extra.vmServiceUri = uri;
+  if (device) extra.toolArgs = ["-d", device];
+  return {
+    ...base(rc, adapter, cwd),
+    request: "attach",
+    program: null,
+    extraJson: JSON.stringify(extra),
+  };
+}
+
 /**
  * The launch configuration that debugs `rc`, or `null` when it has no adapter.
  * `root` is the project root (default working directory).
@@ -321,6 +364,9 @@ export function launchConfigFor(rc: RunConfig, root: string): LaunchConfig | nul
   const adapter = rc.debugAdapter;
   if (!adapter || debugUnsupportedReason(rc)) return null;
   const cwd = rc.cwd ? join(root, rc.cwd) : root;
+  if (adapter === "dart") {
+    return rc.params?.request === "attach" ? flutterAttach(rc, cwd, adapter) : flutterLaunch(rc, cwd, adapter);
+  }
   if (adapter === "codelldb" || adapter === "lldb-dap") {
     return rc.kind === "cargo" ? cargoLaunch(rc, cwd, adapter) : nativeLaunch(rc, cwd, adapter);
   }
diff --git a/src/features/debugger/state.ts b/src/features/debugger/state.ts
index 130e533d5..1bcbd3dc2 100644
--- a/src/features/debugger/state.ts
+++ b/src/features/debugger/state.ts
@@ -23,6 +23,7 @@ import {
   type ThreadInfo,
   type Variable,
 } from "@/platform/ipc";
+import { confirmTerminate } from "@/workbench/confirmTerminate";
 import { maybeEditorService, notifications, toolWindowService, useDebugRunSessions } from "@/workbench/contributions";
 import { breakpointsOf, consumeTemporary, flushBreakpoints, refreshStates, resetStatuses } from "./breakpoints/store";
 import { interpolateLog, logParts, suspends } from "./breakpoints/model";
@@ -327,6 +328,8 @@ export function publishContext() {
   setContext("debugSessionActive", anyLive);
   setContext("debugSessionRunning", s?.status === "running");
   setContext("debugSessionPaused", s?.status === "paused");
+  // Dart and Flutter sessions: Hot Reload / Hot Restart.
+  setContext("debugSessionDart", !!s && rootOf(s).adapter === "dart");
   setContext("debugCanRerun", !!s && !!(rootOf(s).runConfig || rootOf(s).launch));
   setContext(
     "debugCanHotSwap",
@@ -632,6 +635,51 @@ export async function stopSession(id: DebugSessionId, options: { stopProcess?: b
     await call(commands.runStop(root.process)).catch(() => undefined);
 }
 
+/**
+ * Closes a session's tab: a live session is stopped first once the user agrees (the Run
+ * tab's question), then the window forgets it — and its children.
+ */
+export async function closeSessionTab(id: DebugSessionId): Promise<boolean> {
+  const s = useDebug.getState().sessions[id];
+  if (!s) return false;
+  if (isLive(s)) {
+    if (workflowSettings().run.confirmTerminate && !(await confirmTerminate(s.name))) return false;
+    await stopSession(s.id);
+  }
+  removeSession(s.id);
+  return true;
+}
+
+/** Forgets a session and its children; a selected one passes the selection to the tab on its left. */
+export function removeSession(id: DebugSessionId) {
+  const st = useDebug.getState();
+  const gone = new Set<DebugSessionId>([id]);
+  for (const s of Object.values(st.sessions)) if (s.parent === id) gone.add(s.id);
+
+  const order = Object.values(st.sessions).map((s) => s.id);
+  const sessions: Record<number, DebugSession> = {};
+  for (const s of Object.values(st.sessions)) if (!gone.has(s.id)) sessions[s.id] = s;
+  const console = { ...st.console };
+  for (const goneId of gone) delete console[goneId];
+  const at = order.indexOf(id);
+  const neighbour =
+    order
+      .slice(0, at)
+      .reverse()
+      .find((n) => sessions[n]) ??
+    order.slice(at + 1).find((n) => sessions[n]) ??
+    null;
+
+  useDebug.setState({
+    sessions,
+    active: st.active != null && sessions[st.active] ? st.active : neighbour,
+    console,
+  });
+  for (const goneId of gone) owned.delete(goneId);
+  updateExecutionPoint();
+  publishContext();
+}
+
 export async function rerunSession(id: DebugSessionId) {
   const s = useDebug.getState().sessions[id];
   if (!s) return;
diff --git a/src/features/debugger/ui/DebugToolWindow.tsx b/src/features/debugger/ui/DebugToolWindow.tsx
index 70d990d53..e457f0fd5 100644
--- a/src/features/debugger/ui/DebugToolWindow.tsx
+++ b/src/features/debugger/ui/DebugToolWindow.tsx
@@ -26,11 +26,13 @@ import { frameLabel, groupFrames } from "../frames";
 import { blurDebugView, focusDebugView } from "./focusedView";
 import {
   addWatch,
+  closeSessionTab,
   evaluate,
   selectFrame,
   selectSession,
   selectThread,
   revealFrame,
+  rootOf,
   sessionSupports,
   useDebug,
   type DebugSession,
@@ -120,6 +122,7 @@ export function DebugTabs() {
     text: s.name,
     icon: "debug",
     italic: s.status === "terminated",
+    closable: true,
     tooltip: statusText(s),
   }));
   return (
@@ -130,6 +133,7 @@ export function DebugTabs() {
       items={items}
       activeId={active != null ? String(active) : null}
       onSelect={(id) => selectSession(+id)}
+      onClose={(id) => void closeSessionTab(+id)}
       panelIdPrefix="openidea-debug"
     />
   );
@@ -197,6 +201,13 @@ export function DebugToolWindow() {
         <ToolButton action="debug.stepInto" icon="step-into" />
         <ToolButton action="debug.stepOut" icon="step-out" />
         <span className={styles.sep} aria-hidden />
+        {rootOf(active).adapter === "dart" && (
+          <>
+            <ToolButton action="debug.hotReload" icon="hot-reload" />
+            <ToolButton action="debug.hotRestart" icon="refresh" />
+            <span className={styles.sep} aria-hidden />
+          </>
+        )}
         <IconButton
           icon="view-breakpoints"
           action="debug.viewBreakpoints"
diff --git a/src/features/deployment/actions.test.tsx b/src/features/deployment/actions.test.tsx
index 63ab8cdb8..6ad60a217 100644
--- a/src/features/deployment/actions.test.tsx
+++ b/src/features/deployment/actions.test.tsx
@@ -109,6 +109,32 @@ describe("deployment eligibility", () => {
     expect(useDeployment.getState().sync).toBeNull();
     expect(mocks.compare).not.toHaveBeenCalled();
   });
+  it("opens default-server synchronization in a native window on desktop too", async () => {
+    mocks.desktop = true;
+    // The default server needs no choice, and on desktop nothing opens in the page.
+    mocks.actions
+      .find((action) => action.id === "deployment.syncWithDefault")!
+      .run({ arg: ["/project/a", "/project/b"] });
+    await vi.waitFor(() => expect(mocks.openWindow).toHaveBeenCalledWith("one", ["/project/a", "/project/b"]));
+    expect(mocks.choose).not.toHaveBeenCalled();
+    expect(useDeployment.getState().sync).toBeNull();
+    expect(mocks.compare).not.toHaveBeenCalled();
+  });
+  it.each(["deployment.syncWith", "deployment.syncWithDefault"])(
+    "reports a comparison window that cannot open (%s)",
+    async (action) => {
+      mocks.desktop = true;
+      mocks.choose.mockResolvedValue("one");
+      mocks.openWindow.mockRejectedValueOnce(new Error("window failed"));
+      await run(action);
+      await vi.waitFor(() =>
+        expect(mocks.notify).toHaveBeenCalledWith(
+          expect.objectContaining({ title: expect.stringContaining("Cannot open comparison") }),
+        ),
+      );
+      expect(useDeployment.getState().sync).toBeNull();
+    },
+  );
   it("saves edits made in the local diff before synchronization and stops if saving fails", async () => {
     await run("deployment.syncWith");
     mocks.choose.mockResolvedValue("one");
diff --git a/src/features/deployment/actions.tsx b/src/features/deployment/actions.tsx
index 2c558afbb..f3bd0822e 100644
--- a/src/features/deployment/actions.tsx
+++ b/src/features/deployment/actions.tsx
@@ -225,6 +225,16 @@ async function deleteRemote(paths: string[]) {
 }
 
 /** Compares every covered selection with `server`. */
+/** Sync with Deployed to: its own window on desktop (the browser build keeps the in-page dialog). */
+async function openComparison(server: DeploymentServerValid, paths: string[]) {
+  if (!isTauri()) return openSync(server, paths);
+  try {
+    await showDeploymentComparison(server.id, paths);
+  } catch (error) {
+    showFailure("Cannot open comparison for {server}", server, error);
+  }
+}
+
 export async function openSync(server: DeploymentServerValid, paths: string[]) {
   const coverage = (await serverCoverage(paths))?.find((c) => c.server === server.id);
   if (!coverage) return;
@@ -453,15 +463,7 @@ export function registerDeploymentActions(): () => void {
         const target = paths[0] ?? projectRoot();
         if (!target) return;
         const targets = paths.length ? paths : [target];
-        void pickServer("Sync with Deployed to", targets).then(async (server) => {
-          if (!server) return;
-          if (!isTauri()) return openSync(server, targets);
-          try {
-            await showDeploymentComparison(server.id, targets);
-          } catch (error) {
-            showFailure("Cannot open comparison for {server}", server, error);
-          }
-        });
+        void pickServer("Sync with Deployed to", targets).then((server) => server && openComparison(server, targets));
       },
     },
     {
@@ -473,7 +475,7 @@ export function registerDeploymentActions(): () => void {
       keywords: ["deploy", "sftp", "compare", "synchronize", "remote", "diff"],
       run: withTargets(async (paths) => {
         const server = await defaultServer("Sync with Deployed to", paths);
-        if (server) await openSync(server, paths);
+        if (server) await openComparison(server, paths);
       }),
     },
     {
diff --git a/src/features/github/index.ts b/src/features/github/index.ts
index 526c07631..433aa314c 100644
--- a/src/features/github/index.ts
+++ b/src/features/github/index.ts
@@ -144,8 +144,9 @@ function actions(): Action[] {
       id: "github.changeRepository",
       title: "Change Repository or Account…",
       category: "GitHub",
-      when: CONNECTED,
-      run: () => changeRepository(),
+      when: WHEN,
+      // Not connected yet: the tool window offers the repository selector, or explains how to log in.
+      run: () => (useGhRepository.getState().connection ? changeRepository() : void showPullRequests()),
     },
     {
       // pull.request.select.action
diff --git a/src/features/github/toolwindow/toolwindow.test.tsx b/src/features/github/toolwindow/toolwindow.test.tsx
index 269dee84f..fd40645f4 100644
--- a/src/features/github/toolwindow/toolwindow.test.tsx
+++ b/src/features/github/toolwindow/toolwindow.test.tsx
@@ -3,7 +3,7 @@ import { act, render, screen } from "@testing-library/react";
 import { getAction } from "@/platform/actions";
 import { getContext } from "@/platform/context";
 import * as ipc from "@/platform/ipc";
-import { useContributions } from "@/workbench/contributions";
+import { provideToolWindowService, useContributions, type ToolWindowService } from "@/workbench/contributions";
 import { activate } from "../index";
 import { setCurrentRepository } from "../api/client";
 import type { GHRepository, GHUser } from "../api/types";
@@ -114,6 +114,14 @@ describe("tool window", () => {
       expect(getAction(id), id).toBeDefined();
   });
 
+  it("opens the tool window for Change Repository or Account while not connected", async () => {
+    const show = vi.fn();
+    provideToolWindowService({ show } as unknown as ToolWindowService);
+    useGhRepository.setState({ availability: { kind: "notInstalled" } });
+    await getAction("github.changeRepository")!.run({ arg: undefined, ctx: { projectOpen: true } });
+    expect(show).toHaveBeenCalledWith("pullRequests", true);
+  });
+
   it("shows gh's state when it is not ready", () => {
     useGhRepository.setState({ availability: { kind: "notInstalled" } });
     render(<PullRequestsToolWindow />);
diff --git a/src/features/http-client/spring/routeIndex.test.ts b/src/features/http-client/spring/routeIndex.test.ts
index 6299973a5..28521dda4 100644
--- a/src/features/http-client/spring/routeIndex.test.ts
+++ b/src/features/http-client/spring/routeIndex.test.ts
@@ -61,6 +61,23 @@ describe("the Spring endpoint provider", () => {
     expect(scanSources).toHaveBeenCalledTimes(2);
   });
 
+  it("matches sources by path segments, whatever separator the host used", async () => {
+    scanSources.mockResolvedValue({
+      status: "ok",
+      data: [
+        { ...source(), path: "D:\\work\\demo\\src\\DeepLinkController.java" },
+        { ...source("other"), path: "D:/work/demo2/DeepLinkController.java" },
+      ],
+    });
+    expect(await routeIndex("D:/work/demo")).toMatchObject([
+      {
+        methodName: "searchMenus",
+        path: "D:/work/demo/src/DeepLinkController.java",
+        rel: "src/DeepLinkController.java",
+      },
+    ]);
+  });
+
   it.each(["created", "modified", "removed"] as const)("invalidates on %s mapping sources", async (kind) => {
     scanSources.mockResolvedValue({ status: "ok", data: [source()] });
     dispose = registerSpringEndpointProvider();
diff --git a/src/features/http-client/spring/routeIndex.ts b/src/features/http-client/spring/routeIndex.ts
index edbb84048..2388a828c 100644
--- a/src/features/http-client/spring/routeIndex.ts
+++ b/src/features/http-client/spring/routeIndex.ts
@@ -1,5 +1,6 @@
 /** Spring request-path index, cached per project until a mapping source changes. */
 import { call, commands, onIdeEvent } from "@/platform/ipc";
+import { ipcPath, isSameOrInside } from "@/platform/paths";
 import { registerEndpointProvider, type EndpointEntry } from "@/workbench/contributions";
 import { springControllers } from "./endpoints";
 
@@ -40,8 +41,10 @@ export function routeIndex(root: string | null): Promise<EndpointEntry[]> {
 async function scan(root: string): Promise<EndpointEntry[]> {
   const sources = await call(commands.springRouteSources());
   const routes: EndpointEntry[] = [];
+  const base = ipcPath(root).replace(/\/$/, "");
   for (const source of sources) {
-    if (!source.path.startsWith(root)) continue;
+    const path = ipcPath(source.path);
+    if (!isSameOrInside(path, base)) continue;
     for (const controller of springControllers(source.text)) {
       for (const endpoint of controller.endpoints) {
         const at = lineCol(source.text, endpoint.offset);
@@ -53,8 +56,8 @@ async function scan(root: string): Promise<EndpointEntry[]> {
             url,
             controller: controller.name,
             methodName: endpoint.methodName,
-            path: source.path,
-            rel: source.path.slice(root.length + 1),
+            path,
+            rel: path.slice(base.length + 1),
             line: at.line,
             col: at.col,
           });
diff --git a/src/features/index.ts b/src/features/index.ts
index 5086d7790..cd58ab5b9 100644
--- a/src/features/index.ts
+++ b/src/features/index.ts
@@ -26,6 +26,7 @@ import { activate as debuggerFeature } from "./debugger";
 import { activate as coverage } from "./coverage";
 import { activate as colorPreview } from "./color-preview";
 import { activate as profiler } from "./profiler";
+import { activate as logcat } from "./logcat";
 import { activate as buildTools } from "./build-tools";
 import { activate as build } from "./build";
 import { activate as templates, activateSettingsPages as templatesPages } from "./templates";
@@ -73,6 +74,7 @@ const features: Array<[string, Activate]> = [
   ["coverage", coverage],
   ["color-preview", colorPreview],
   ["profiler", profiler],
+  ["logcat", logcat],
   ["build-tools", buildTools],
   ["build", build],
   ["templates", templates],
diff --git a/src/features/logcat/Logcat.module.css b/src/features/logcat/Logcat.module.css
new file mode 100644
index 000000000..66923ee43
--- /dev/null
+++ b/src/features/logcat/Logcat.module.css
@@ -0,0 +1,144 @@
+.view {
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+  min-height: 0;
+  background: var(--bg-editor);
+}
+
+.toolbar {
+  flex: none;
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  padding: 4px 8px;
+  border-bottom: 1px solid var(--border);
+  background: var(--bg-elev);
+}
+
+.device {
+  width: 220px;
+  min-width: 0;
+}
+.level {
+  width: 130px;
+  flex: none;
+}
+.search {
+  flex: 1;
+  min-width: 80px;
+}
+
+/* The virtual list: rows are absolutely positioned inside a spacer of total height. */
+.log {
+  flex: 1;
+  min-height: 0;
+  overflow: auto;
+  font-family: var(--font-mono);
+  font-size: var(--fs-code);
+  line-height: var(--lh-code);
+  color: var(--fg-editor);
+  -webkit-user-select: text;
+  user-select: text;
+  cursor: text;
+  position: relative;
+}
+.canvas {
+  position: relative;
+  width: 100%;
+}
+.row {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  display: flex;
+  gap: 8px;
+  padding: 0 8px;
+  box-sizing: border-box;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+}
+.row:hover {
+  background: var(--bg-hover);
+}
+.time {
+  flex: none;
+  width: 92px;
+  color: var(--fg-subtle);
+}
+.pid {
+  flex: none;
+  width: 44px;
+  text-align: right;
+  color: var(--fg-subtle);
+}
+.tag {
+  flex: none;
+  max-width: 180px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  color: var(--fg-muted);
+}
+.message {
+  flex: 1;
+  min-width: 0;
+}
+
+/* Level colours follow Android Studio: errors red, warnings amber, info default,
+   debug/verbose muted, and lines outside the message format dimmed. */
+.levelV,
+.levelD,
+.levelU {
+  color: var(--fg-subtle);
+}
+.levelI {
+  color: var(--fg-editor);
+}
+.levelW {
+  color: var(--warning);
+}
+.levelE,
+.levelF {
+  color: var(--danger);
+}
+.levelF .message {
+  font-weight: 600;
+}
+
+.empty {
+  position: absolute;
+  inset: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  color: var(--fg-subtle);
+  font-family: var(--font-ui);
+  font-size: var(--fs-small);
+  pointer-events: none;
+}
+
+.status {
+  flex: none;
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 2px 8px;
+  border-top: 1px solid var(--border);
+  color: var(--fg-subtle);
+  font-size: var(--fs-small);
+  white-space: nowrap;
+  overflow: hidden;
+}
+.count {
+  margin-left: auto;
+}
+.warn {
+  color: var(--warning);
+}
+.error {
+  color: var(--danger);
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
diff --git a/src/features/logcat/LogcatView.tsx b/src/features/logcat/LogcatView.tsx
new file mode 100644
index 000000000..500d0b1cf
--- /dev/null
+++ b/src/features/logcat/LogcatView.tsx
@@ -0,0 +1,280 @@
+/**
+ * Logcat tool window: the device picker, the level and text filters, and the
+ * streaming log below them (virtualised, following the tail until scrolled up).
+ */
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef } from "react";
+import clsx from "clsx";
+import { useVirtualizer } from "@tanstack/react-virtual";
+import { Channel } from "@tauri-apps/api/core";
+import { call, commands, isCancelled, nextRequestId } from "@/platform/ipc";
+import type { LogcatLevel, LogcatLine } from "@/platform/ipc";
+import { Input, IconButton, Select, T, EmptyState, showContextMenu, type MenuItem } from "@/ui";
+import { FILTER_LEVELS, LEVEL_CLASS, filterLines, shortTime } from "./model";
+import { compileQuery } from "./query";
+import { forgetFilters, rememberFilter } from "./history";
+import { appendLines, clearLines, setDevices, setDevicesError, setPaused, setStatus, useLogcat } from "./store";
+import styles from "./Logcat.module.css";
+
+/** Rows are measured: a wrapped message makes its row taller. */
+const ROW_HEIGHT = 22;
+const LEVEL_LABELS: Record<LogcatLevel, string> = {
+  verbose: "Verbose",
+  debug: "Debug",
+  info: "Info",
+  warn: "Warnings",
+  error: "Errors",
+  fatal: "Fatal",
+  unknown: "Unknown",
+};
+
+/** The device whose log the buffer holds: reopening the window keeps it, switching
+ * devices starts clean. */
+let bufferedFor: string | null = null;
+
+function message(e: unknown): string {
+  return e instanceof Error ? e.message : String(e);
+}
+
+export function LogcatView() {
+  const devices = useLogcat((s) => s.devices);
+  const devicesError = useLogcat((s) => s.devicesError);
+  const loadingDevices = useLogcat((s) => s.loadingDevices);
+  const serial = useLogcat((s) => s.serial);
+  const level = useLogcat((s) => s.level);
+  const query = useLogcat((s) => s.query);
+  const history = useLogcat((s) => s.history);
+  const paused = useLogcat((s) => s.paused);
+  const follow = useLogcat((s) => s.follow);
+  const status = useLogcat((s) => s.status);
+  const error = useLogcat((s) => s.error);
+  const lines = useLogcat((s) => s.lines);
+
+  const refreshDevices = useCallback(() => {
+    useLogcat.setState({ loadingDevices: true });
+    call(commands.androidDevices())
+      .then(setDevices)
+      .catch((e) => setDevicesError(message(e)));
+  }, []);
+
+  useEffect(() => {
+    refreshDevices();
+  }, [refreshDevices]);
+
+  const scrollRef = useRef<HTMLDivElement>(null);
+  /** The scrollTop we last wrote: only the user can move the view above it. */
+  const written = useRef(0);
+  /** Where ↑/↓ are in the history; `null` while the box holds freshly typed text. */
+  const browse = useRef<{ index: number; draft: string } | null>(null);
+
+  /** ↑ walks back in time, ↓ returns to what was typed (−1 is that draft). */
+  const recall = (step: 1 | -1) => {
+    if (!history.length) return;
+    if (!browse.current) browse.current = { index: -1, draft: query };
+    const index = Math.max(-1, Math.min(browse.current.index + step, history.length - 1));
+    if (index === browse.current.index) return;
+    browse.current.index = index;
+    useLogcat.setState({ query: index < 0 ? browse.current.draft : history[index]! });
+  };
+
+  const applyFilter = (value: string) => {
+    browse.current = null;
+    useLogcat.setState({ query: value, history: rememberFilter(value) });
+  };
+
+  const historyItems = (): MenuItem[] => [
+    ...history.map((entry) => ({ label: entry, verbatim: true, run: () => applyFilter(entry) })),
+    { kind: "separator" as const },
+    { label: "Clear History", run: () => useLogcat.setState({ history: forgetFilters() }) },
+  ];
+
+  // One stream per device: switching devices (or closing the window) cancels it.
+  useEffect(() => {
+    if (!serial) {
+      setStatus("idle");
+      return;
+    }
+    if (bufferedFor !== serial) {
+      clearLines();
+      bufferedFor = serial;
+      written.current = 0;
+    }
+    const request = nextRequestId();
+    const channel = new Channel<LogcatLine[]>();
+    channel.onmessage = (batch) => appendLines(batch);
+    setStatus("running");
+    call(commands.androidLogcat(request, serial, false, channel))
+      .then(() => setStatus("idle"))
+      .catch((e) => {
+        if (isCancelled(e)) setStatus("idle");
+        else setStatus("error", message(e));
+      });
+    return () => {
+      void commands.cancelRequest(request);
+    };
+  }, [serial]);
+
+  const rows = useMemo(() => filterLines(lines, level, query), [lines, level, query]);
+  const filterError = useMemo(() => compileQuery(query).error, [query]);
+  const virtualizer = useVirtualizer({
+    count: rows.length,
+    getScrollElement: () => scrollRef.current,
+    estimateSize: () => ROW_HEIGHT,
+    // Rows are identified by their line, not by position: the buffer drops old lines.
+    getItemKey: (index) => rows[index]!.id,
+    overscan: 16,
+  });
+
+  // Follow the tail: `totalSize` changes only after the rows below have been
+  // measured, so waiting on it as well is what lands us on the real last line
+  // when a burst arrives (React commits, the virtualiser measures, this runs again).
+  const totalSize = virtualizer.getTotalSize();
+  useLayoutEffect(() => {
+    if (!follow) return;
+    const el = scrollRef.current;
+    if (!el) return;
+    el.scrollTop = el.scrollHeight;
+    written.current = el.scrollTop;
+  }, [rows, follow, totalSize]);
+
+  const deviceOptions = devices.map((d) => ({
+    value: d.serial,
+    label: d.model ? `${d.model} (${d.serial})` : d.serial,
+    detail: d.state === "device" ? undefined : d.state,
+    disabled: d.state !== "device",
+  }));
+
+  return (
+    <div className={styles.view}>
+      <div className={styles.toolbar}>
+        <Select
+          className={styles.device}
+          aria-label={"Device"}
+          placeholder="No devices"
+          value={serial}
+          options={deviceOptions}
+          onChange={(value) => useLogcat.setState({ serial: value })}
+        />
+        <Select
+          className={styles.level}
+          aria-label={"Minimum level"}
+          value={level}
+          options={FILTER_LEVELS.map((value) => ({ value, label: LEVEL_LABELS[value] }))}
+          onChange={(value) => useLogcat.setState({ level: value })}
+        />
+        <Input
+          className={styles.search}
+          placeholder="Filter, e.g. tag:glide -message:bitmap level:error"
+          aria-label={"Filter log lines"}
+          title={"tag: · message: · pid: · level: · -term · a|b · (a|b) -c · message~:regex · ↑ for history"}
+          invalid={filterError !== null}
+          value={query}
+          onKeyDown={(e) => {
+            if (e.key === "Enter") {
+              useLogcat.setState({ history: rememberFilter(query) });
+              browse.current = null;
+            } else if (e.key === "ArrowUp" || e.key === "ArrowDown") {
+              e.preventDefault();
+              recall(e.key === "ArrowUp" ? 1 : -1);
+            }
+          }}
+          onChange={(e) => {
+            browse.current = null;
+            useLogcat.setState({ query: e.target.value });
+          }}
+        />
+        <IconButton
+          icon="history"
+          title="Filter history"
+          size="small"
+          disabled={!history.length}
+          onClick={(e) => showContextMenu({ clientX: e.clientX, clientY: e.clientY }, historyItems())}
+        />
+        <IconButton
+          icon={paused ? "resume" : "pause"}
+          title={paused ? "Resume" : "Pause"}
+          size="small"
+          pressed={paused}
+          onClick={() => setPaused(!paused)}
+        />
+        <IconButton
+          icon="arrow-down"
+          title={follow ? "Following the end (click to stop)" : "Scroll to end"}
+          size="small"
+          pressed={follow}
+          onClick={() => useLogcat.setState({ follow: !follow })}
+        />
+        <IconButton icon="trash" title="Clear" size="small" onClick={clearLines} />
+        <IconButton
+          icon="refresh"
+          title="Refresh devices"
+          size="small"
+          disabled={loadingDevices}
+          onClick={refreshDevices}
+        />
+      </div>
+
+      {devicesError ? (
+        <EmptyState title="No Android devices">
+          <span>{devicesError}</span>
+        </EmptyState>
+      ) : !devices.length ? (
+        <EmptyState title={loadingDevices ? "Looking for devices…" : "No Android devices"}>
+          <span>
+            <T>Connect a device over USB, or start an emulator. Logcat uses the Android SDK's adb.</T>
+          </span>
+        </EmptyState>
+      ) : (
+        <div
+          ref={scrollRef}
+          className={styles.log}
+          role="log"
+          aria-label={"Device log"}
+          tabIndex={0}
+          onScroll={(e) => {
+            const el = e.currentTarget;
+            // Our own writes always end at the bottom, so a move upwards is the user's:
+            // scrolling up stops following, and only the toolbar arrow resumes it.
+            const up = el.scrollTop < written.current - 4;
+            written.current = el.scrollTop;
+            if (up && follow) useLogcat.setState({ follow: false });
+          }}
+        >
+          <div className={styles.canvas} style={{ height: virtualizer.getTotalSize() }}>
+            {virtualizer.getVirtualItems().map((item) => {
+              const line = rows[item.index]!;
+              return (
+                <div
+                  key={item.key}
+                  ref={virtualizer.measureElement}
+                  data-index={item.index}
+                  className={clsx(styles.row, styles[LEVEL_CLASS[line.level]])}
+                  style={{ transform: `translateY(${item.start}px)` }}
+                >
+                  <span className={styles.time}>{shortTime(line.time)}</span>
+                  <span className={styles.pid}>{line.pid || ""}</span>
+                  <span className={styles.tag}>{line.tag}</span>
+                  <span className={styles.message}>{line.message}</span>
+                </div>
+              );
+            })}
+          </div>
+          {!rows.length && (
+            <div className={styles.empty}>
+              {lines.length ? <T>No lines match the filter</T> : <T>Waiting for output…</T>}
+            </div>
+          )}
+        </div>
+      )}
+
+      <div className={styles.status}>
+        <span>{status === "running" ? <T>Streaming</T> : status === "error" ? <T>Stopped</T> : <T>Idle</T>}</span>
+        {paused && <span className={styles.warn}>Paused</span>}
+        {filterError && <span className={styles.error}>Filter ignored: {filterError}</span>}
+        <span className={styles.count}>
+          {rows.length === lines.length ? lines.length : `${rows.length} / ${lines.length}`}
+        </span>
+        {error && <span className={styles.error}>{error}</span>}
+      </div>
+    </div>
+  );
+}
diff --git a/src/features/logcat/history.test.ts b/src/features/logcat/history.test.ts
new file mode 100644
index 000000000..e446c4497
--- /dev/null
+++ b/src/features/logcat/history.test.ts
@@ -0,0 +1,56 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { forgetFilters, loadFilters, rememberFilter } from "./history";
+
+const KEY = "openidea.logcat.filters";
+
+function fakeStorage(): Storage {
+  const map = new Map<string, string>();
+  return {
+    get length() {
+      return map.size;
+    },
+    clear: () => map.clear(),
+    getItem: (k: string) => map.get(k) ?? null,
+    key: (i: number) => [...map.keys()][i] ?? null,
+    removeItem: (k: string) => void map.delete(k),
+    setItem: (k: string, v: string) => void map.set(k, v),
+  } as Storage;
+}
+
+beforeEach(() => {
+  vi.stubGlobal("localStorage", fakeStorage());
+  forgetFilters();
+});
+
+afterEach(() => vi.unstubAllGlobals());
+
+describe("filter history", () => {
+  it("keeps the newest first without duplicates", () => {
+    rememberFilter("tag:aa");
+    rememberFilter("tag:bb");
+    expect(loadFilters()).toEqual(["tag:bb", "tag:aa"]);
+    expect(rememberFilter("  tag:aa ")).toEqual(["tag:aa", "tag:bb"]);
+  });
+
+  it("takes ↑/↓ order from the list and ignores an empty filter", () => {
+    expect(rememberFilter("   ")).toEqual([]);
+    for (let i = 0; i < 30; i++) rememberFilter(`tag:${i}`);
+    const list = loadFilters();
+    expect(list).toHaveLength(20);
+    expect(list[0]).toBe("tag:29");
+    expect(list.at(-1)).toBe("tag:10");
+  });
+
+  it("survives storage content that is not a list", () => {
+    localStorage.setItem(KEY, "{not json");
+    expect(loadFilters()).toEqual([]);
+    localStorage.setItem(KEY, JSON.stringify([1, "", "tag:x"]));
+    expect(loadFilters()).toEqual(["tag:x"]);
+  });
+
+  it("works when storage is unavailable", () => {
+    vi.stubGlobal("localStorage", undefined);
+    expect(loadFilters()).toEqual([]);
+    expect(rememberFilter("tag:aa")).toEqual(["tag:aa"]);
+  });
+});
diff --git a/src/features/logcat/history.ts b/src/features/logcat/history.ts
new file mode 100644
index 000000000..05673ee13
--- /dev/null
+++ b/src/features/logcat/history.ts
@@ -0,0 +1,47 @@
+/**
+ * Recent filter expressions of the Logcat tool window, kept in `localStorage` so
+ * they survive a restart (IDEA's logcat keeps a short history too). Newest first.
+ */
+const KEY = "openidea.logcat.filters";
+const MAX = 20;
+
+function store(): Storage | null {
+  try {
+    return typeof localStorage === "undefined" ? null : localStorage;
+  } catch {
+    return null;
+  }
+}
+
+function save(list: string[]) {
+  try {
+    store()?.setItem(KEY, JSON.stringify(list));
+  } catch {
+    // Storage disabled or full: the history is a convenience, not state to lose sleep over.
+  }
+}
+
+export function loadFilters(): string[] {
+  try {
+    const raw = store()?.getItem(KEY);
+    const parsed: unknown = raw ? JSON.parse(raw) : [];
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter((v): v is string => typeof v === "string" && v.trim() !== "").slice(0, MAX);
+  } catch {
+    return [];
+  }
+}
+
+/** Puts `query` at the front (an empty one is not worth remembering) and returns the new list. */
+export function rememberFilter(query: string): string[] {
+  const text = query.trim();
+  const rest = loadFilters().filter((q) => q !== text);
+  const list = text ? [text, ...rest].slice(0, MAX) : rest;
+  save(list);
+  return list;
+}
+
+export function forgetFilters(): string[] {
+  save([]);
+  return [];
+}
diff --git a/src/features/logcat/index.ts b/src/features/logcat/index.ts
new file mode 100644
index 000000000..5eef15f83
--- /dev/null
+++ b/src/features/logcat/index.ts
@@ -0,0 +1,26 @@
+/**
+ * Logcat tool window: what an Android device prints, via `adb logcat`, with the
+ * level and text filters of IDEA's Android plugin.
+ */
+import { registerToolWindow } from "@/workbench/contributions";
+import { LogcatView } from "./LogcatView";
+import { resetLogcat } from "./store";
+
+export function activate(): () => void {
+  const dispose = registerToolWindow({
+    id: "logcat",
+    title: "Logcat",
+    icon: "toolwindow-logcat",
+    anchor: "bottom",
+    // Listed under the stripe's "…" until first opened: most projects are not Android ones.
+    stripe: "onUse",
+    order: 26,
+    component: LogcatView,
+    // A device can be watched without a project open.
+    requiresProject: false,
+  });
+  return () => {
+    dispose();
+    resetLogcat();
+  };
+}
diff --git a/src/features/logcat/model.test.ts b/src/features/logcat/model.test.ts
new file mode 100644
index 000000000..2aeb461ba
--- /dev/null
+++ b/src/features/logcat/model.test.ts
@@ -0,0 +1,108 @@
+import { describe, expect, it } from "vitest";
+import type { LogcatLine } from "@/platform/ipc";
+import { LEVEL_CLASS, LEVELS, filterLines, shortTime } from "./model";
+import { compileQuery } from "./query";
+
+const line = (level: LogcatLine["level"], tag: string, message: string, pid = 100): LogcatLine => ({
+  time: "11-04 12:52:39.123",
+  pid,
+  tid: pid + 1,
+  level,
+  tag,
+  message,
+});
+
+const lines = [
+  line("verbose", "chatty", "starting up"),
+  line("info", "ActivityManager", "Displayed com.example/.Main"),
+  line("warn", "Glide", "Failed to load bitmap"),
+  line("error", "flutter", "IllegalStateException: boom", 4242),
+  { ...line("unknown", "", "--------- beginning of main") },
+];
+
+describe("filterLines", () => {
+  it("keeps everything at the least severe level", () => {
+    expect(filterLines(lines, "verbose", "")).toHaveLength(5);
+  });
+
+  it("drops lines below the chosen level", () => {
+    expect(filterLines(lines, "warn", "").map((l) => l.tag)).toEqual(["Glide", "flutter", ""]);
+    expect(filterLines(lines, "error", "").map((l) => l.tag)).toEqual(["flutter", ""]);
+  });
+
+  it("matches the tag, the message, and #pid", () => {
+    expect(filterLines(lines, "verbose", "glide")).toHaveLength(1);
+    expect(filterLines(lines, "verbose", "bitmap")).toHaveLength(1);
+    expect(filterLines(lines, "verbose", "#4242").map((l) => l.tag)).toEqual(["flutter"]);
+  });
+
+  it("combines level and text", () => {
+    expect(filterLines(lines, "warn", "boom")).toHaveLength(1);
+    expect(filterLines(lines, "error", "bitmap")).toHaveLength(0);
+  });
+});
+
+describe("filter expressions", () => {
+  const tags = (query: string) => filterLines(lines, "verbose", query).map((l) => l.tag);
+
+  it("drops what a negated term matches", () => {
+    expect(tags("-message:boom")).toEqual(["chatty", "ActivityManager", "Glide", ""]);
+    expect(tags("-tag:glide -tag:flutter")).toEqual(["chatty", "ActivityManager", ""]);
+  });
+
+  it("ands adjacent terms and or-s them with |", () => {
+    expect(tags("tag:glide message:bitmap")).toEqual(["Glide"]);
+    expect(tags("tag:glide|tag:flutter")).toEqual(["Glide", "flutter"]);
+    expect(tags("tag:glide | tag:flutter")).toEqual(["Glide", "flutter"]);
+  });
+
+  it("groups, so a negation can apply to either term", () => {
+    expect(tags("(tag:glide|tag:flutter) -level:error")).toEqual(["Glide"]);
+    expect(tags("-(tag:glide|tag:flutter)")).toEqual(["chatty", "ActivityManager", ""]);
+  });
+
+  it("matches a level by name, letter or list", () => {
+    expect(tags("level:error")).toEqual(["flutter"]);
+    expect(tags("level:w,e")).toEqual(["Glide", "flutter"]);
+    expect(tags("level:ERROR")).toEqual(["flutter"]);
+  });
+
+  it("matches pid and tid, and still #pid", () => {
+    expect(tags("pid:4242")).toEqual(["flutter"]);
+    expect(tags("pid:4243")).toEqual(["flutter"]);
+    expect(tags("#4242")).toEqual(["flutter"]);
+  });
+
+  it("takes a regular expression after ~", () => {
+    expect(tags("message~:^Displayed")).toEqual(["ActivityManager"]);
+    expect(tags("tag~:^ACTIVITY")).toEqual(["ActivityManager"]);
+  });
+
+  it("reads a quoted value, including an empty one", () => {
+    expect(tags('message:"IllegalState boom"')).toEqual([]);
+    expect(tags("message:'IllegalStateException: boom'")).toEqual(["flutter"]);
+    expect(tags('tag:""')).toEqual([""]);
+  });
+
+  it("treats an unknown key as plain text", () => {
+    expect(tags("package:com.example")).toEqual([]);
+  });
+
+  it("ignores an invalid query and says why", () => {
+    expect(compileQuery("tag:((").error).toBeTruthy();
+    expect(compileQuery("message~:(").error).toBeTruthy();
+    expect(compileQuery("").error).toBeNull();
+    expect(tags("tag:((")).toHaveLength(5);
+  });
+});
+
+it("orders levels least severe first, with unknown last so it is never hidden", () => {
+  expect(LEVELS[0]).toBe("verbose");
+  expect(LEVELS.at(-1)).toBe("unknown");
+  expect(LEVELS.indexOf("error")).toBeGreaterThan(LEVELS.indexOf("warn"));
+  expect(LEVEL_CLASS.error).toBe("levelE");
+});
+
+it("shortens a logcat timestamp to the time of day", () => {
+  expect(shortTime("11-04 12:52:39.123")).toBe("12:52:39.123");
+});
diff --git a/src/features/logcat/model.ts b/src/features/logcat/model.ts
new file mode 100644
index 000000000..af1a4daf3
--- /dev/null
+++ b/src/features/logcat/model.ts
@@ -0,0 +1,34 @@
+/** Logcat tool window: filtering and formatting, independent of React. */
+import type { LogcatLevel, LogcatLine } from "@/platform/ipc";
+import { compileQuery } from "./query";
+
+/** Severity order of the level filter, least severe first. `unknown` sits last so
+ * lines logcat prints outside its message format are never filtered away. */
+export const LEVELS: readonly LogcatLevel[] = ["verbose", "debug", "info", "warn", "error", "fatal", "unknown"];
+
+/** The levels the filter offers as a minimum; `unknown` always shows, so it is not one. */
+export const FILTER_LEVELS = LEVELS.filter((level) => level !== "unknown");
+
+/** Row style per level, matching the classes in `Logcat.module.css`. */
+export const LEVEL_CLASS: Record<LogcatLevel, string> = {
+  verbose: "levelV",
+  debug: "levelD",
+  info: "levelI",
+  warn: "levelW",
+  error: "levelE",
+  fatal: "levelF",
+  unknown: "levelU",
+};
+
+/** "11-04 12:52:39.123" → "12:52:39.123": the date is the same for the whole session. */
+export function shortTime(time: string): string {
+  return time.length > 6 ? time.slice(6) : time;
+}
+
+/** Lines at or above `min`, then only those the query accepts (see `query.ts`). */
+export function filterLines<T extends LogcatLine>(lines: readonly T[], min: LogcatLevel, query: string): readonly T[] {
+  const floor = LEVELS.indexOf(min);
+  const filter = compileQuery(query);
+  if (floor === 0 && !query.trim()) return lines;
+  return lines.filter((line) => LEVELS.indexOf(line.level) >= floor && filter.test(line));
+}
diff --git a/src/features/logcat/query.ts b/src/features/logcat/query.ts
new file mode 100644
index 000000000..a0a6f2219
--- /dev/null
+++ b/src/features/logcat/query.ts
@@ -0,0 +1,253 @@
+/**
+ * Logcat filter expressions in the shape Android Studio accepts:
+ *
+ *   tag:glide            the tag contains "glide"
+ *   message:boom         the message contains "boom"
+ *   pid:4242             the process (or thread) id is 4242
+ *   level:error          the level is error (or `level:warn,error`, names or letters)
+ *   -tag:chatty          "not": drops matching lines
+ *   a b                  both, implicitly and-ed (`&` works too)
+ *   a|b                  either, or-ed
+ *   (a|b) -c             grouping
+ *   message~:^Tile.*     a case-insensitive regular expression
+ *   message:"two words"  quoted values, single or double
+ *
+ * A bare word matches the tag, the message, or `#pid`, as before.
+ */
+import type { LogcatLevel, LogcatLine } from "@/platform/ipc";
+
+export type QueryField = "tag" | "message" | "pid" | "level" | "text";
+
+export interface QueryTerm {
+  field: QueryField;
+  value: string;
+  /** `key~:value`: `value` is a regular expression. */
+  regex: boolean;
+}
+
+type QueryNode =
+  | { kind: "term"; term: QueryTerm }
+  | { kind: "not"; node: QueryNode }
+  | { kind: "and"; nodes: QueryNode[] }
+  | { kind: "or"; nodes: QueryNode[] };
+
+export interface LogFilter {
+  /** Whether a line passes. Every line passes when the query is empty or invalid. */
+  test: (line: LogcatLine) => boolean;
+  /** Why an invalid query was ignored, or `null`. */
+  error: string | null;
+}
+
+/** `message` is also the name of a translated UI text, so name the field once. */
+const MESSAGE_FIELD: QueryField = "message";
+
+const FIELD_ALIASES: Record<string, QueryField> = {
+  tag: "tag",
+  message: MESSAGE_FIELD,
+  msg: MESSAGE_FIELD,
+  pid: "pid",
+  level: "level",
+};
+
+const LEVEL_NAMES: Record<string, LogcatLevel> = {
+  verbose: "verbose",
+  v: "verbose",
+  debug: "debug",
+  d: "debug",
+  info: "info",
+  i: "info",
+  warn: "warn",
+  warning: "warn",
+  w: "warn",
+  error: "error",
+  e: "error",
+  fatal: "fatal",
+  assert: "fatal",
+  a: "fatal",
+  f: "fatal",
+  unknown: "unknown",
+};
+
+class QueryError extends Error {}
+
+/** Splits one word into a term. Unknown `key:value` pairs stay plain text. */
+function toTerm(raw: string): QueryTerm {
+  const colon = raw.indexOf(":");
+  if (colon > 0) {
+    let key = raw.slice(0, colon).toLowerCase();
+    const regex = key.endsWith("~");
+    if (regex) key = key.slice(0, -1);
+    const field = FIELD_ALIASES[key];
+    if (field) return { field, value: raw.slice(colon + 1), regex };
+  }
+  return { field: "text", value: raw, regex: false };
+}
+
+class Parser {
+  private index = 0;
+
+  constructor(private readonly source: string) {}
+
+  parse(): QueryNode | null {
+    const node = this.or();
+    if (this.peek() !== "") throw new QueryError(`Unexpected “${this.peek()}”`);
+    return node;
+  }
+
+  /** Whitespace is insignificant; anything else is a token. */
+  private peek(): string {
+    while (this.index < this.source.length && /\s/.test(this.source[this.index]!)) this.index++;
+    return this.source[this.index] ?? "";
+  }
+
+  private or(): QueryNode | null {
+    const nodes: QueryNode[] = [];
+    const first = this.and();
+    if (first) nodes.push(first);
+    while (this.peek() === "|") {
+      this.index++;
+      const next = this.and();
+      if (!next) throw new QueryError("Nothing to match after |");
+      nodes.push(next);
+    }
+    if (!nodes.length) return null;
+    return nodes.length === 1 ? nodes[0]! : { kind: "or", nodes };
+  }
+
+  private and(): QueryNode | null {
+    const nodes: QueryNode[] = [];
+    for (;;) {
+      const next = this.peek();
+      if (next === "" || next === "|" || next === ")") break;
+      if (next === "&") {
+        this.index++;
+        continue;
+      }
+      nodes.push(this.unary());
+    }
+    if (!nodes.length) return null;
+    return nodes.length === 1 ? nodes[0]! : { kind: "and", nodes };
+  }
+
+  private unary(): QueryNode {
+    const next = this.peek();
+    if (next === "-" || next === "!") {
+      this.index++;
+      return { kind: "not", node: this.unary() };
+    }
+    if (next === "(") {
+      this.index++;
+      const node = this.or();
+      if (!node) throw new QueryError("Empty parentheses");
+      if (this.peek() !== ")") throw new QueryError("Missing )");
+      this.index++;
+      return node;
+    }
+    const word = this.word();
+    if (!word) throw new QueryError(`Unexpected “${next}”`);
+    return { kind: "term", term: toTerm(word) };
+  }
+
+  /** A run of characters up to whitespace or a separator, quotes removed. */
+  private word(): string {
+    let word = "";
+    for (;;) {
+      const c = this.source[this.index];
+      if (c === undefined || /\s/.test(c) || c === "|" || c === "&" || c === ")" || c === "(") break;
+      if (c === '"' || c === "'") {
+        this.index++;
+        while (this.index < this.source.length && this.source[this.index] !== c) {
+          word += this.source[this.index]!;
+          this.index++;
+        }
+        if (this.index < this.source.length) this.index++;
+        continue;
+      }
+      word += c;
+      this.index++;
+    }
+    return word;
+  }
+}
+
+function levels(value: string): Set<LogcatLevel> {
+  const names = value.split(",").map((part) => part.trim().toLowerCase());
+  const chosen = new Set<LogcatLevel>();
+  for (const name of names) {
+    const level = LEVEL_NAMES[name];
+    if (!level) throw new QueryError(`Unknown level “${name}”`);
+    chosen.add(level);
+  }
+  return chosen;
+}
+
+function termMatcher(term: QueryTerm): (line: LogcatLine) => boolean {
+  const value = term.value.toLowerCase();
+  const named = term.field === "level" ? levels(term.value) : null;
+  const pattern = term.regex && term.field !== "level" ? new RegExp(term.value, "i") : null;
+
+  const hit = (text: string): boolean => {
+    if (!term.regex) return value.length === 0 ? text.length === 0 : text.toLowerCase().includes(value);
+    return pattern!.test(text);
+  };
+
+  switch (term.field) {
+    case "tag":
+      return (line) => hit(line.tag);
+    case "message":
+      return (line) => hit(line.message);
+    case "pid":
+      return (line) => line.pid === Number(term.value) || line.tid === Number(term.value);
+    case "level":
+      return (line) => named!.has(line.level);
+    case "text": {
+      const hash = value.startsWith("#") ? value.slice(1) : null;
+      return (line) =>
+        hit(line.message) ||
+        hit(line.tag) ||
+        (hash !== null && (String(line.pid) === hash || String(line.tid) === hash));
+    }
+  }
+}
+
+function compile(node: QueryNode): (line: LogcatLine) => boolean {
+  switch (node.kind) {
+    case "term":
+      return termMatcher(node.term);
+    case "not": {
+      const inner = compile(node.node);
+      return (line) => !inner(line);
+    }
+    case "and": {
+      const parts = node.nodes.map(compile);
+      return (line) => parts.every((part) => part(line));
+    }
+    case "or": {
+      const parts = node.nodes.map(compile);
+      return (line) => parts.some((part) => part(line));
+    }
+  }
+}
+
+const cache = new Map<string, LogFilter>();
+
+/** Parses and compiles a query. Compiling is cached: the filter runs per line. */
+export function compileQuery(query: string): LogFilter {
+  const source = query.trim();
+  if (!source) return { test: () => true, error: null };
+  const hit = cache.get(source);
+  if (hit) return hit;
+
+  let filter: LogFilter;
+  try {
+    const node = new Parser(source).parse();
+    filter = node ? { test: compile(node), error: null } : { test: () => true, error: null };
+  } catch (e) {
+    filter = { test: () => true, error: e instanceof Error ? e.message : String(e) };
+  }
+
+  // A handful of entries is enough: there is one query per keystroke at most.
+  if (cache.size >= 32) cache.delete(cache.keys().next().value!);
+  cache.set(source, filter);
+  return filter;
+}
diff --git a/src/features/logcat/store.ts b/src/features/logcat/store.ts
new file mode 100644
index 000000000..a5d06e3ab
--- /dev/null
+++ b/src/features/logcat/store.ts
@@ -0,0 +1,130 @@
+/**
+ * Logcat tool window state: the device being watched, the lines streamed from it
+ * and the filters over them. The stream itself lives in the view (one per window).
+ */
+import { create } from "zustand";
+import type { AndroidDevice, LogcatLevel, LogcatLine } from "@/platform/ipc";
+import { loadFilters } from "./history";
+
+/** Kept lines; a chatty device must not grow the buffer without bound. */
+export const MAX_LINES = 20_000;
+
+export type LogcatStatus = "idle" | "running" | "error";
+
+/** A line plus the identity the list needs: the buffer drops old lines from the
+ * front, so the index is not stable. */
+export interface LogcatRow extends LogcatLine {
+  id: number;
+}
+
+interface LogcatState {
+  devices: AndroidDevice[];
+  devicesError: string | null;
+  loadingDevices: boolean;
+  /** `adb -s` value of the device being watched. */
+  serial: string | null;
+  /** Drop lines below this level. */
+  level: LogcatLevel;
+  /** Filter expression: `tag:`, `message:`, `-term`, … (see `query.ts`). */
+  query: string;
+  /** Filters used before, newest first; ↑/↓ and the toolbar list walk it. */
+  history: string[];
+  /** Freeze the view: lines keep arriving but are only applied when resumed. */
+  paused: boolean;
+  /** Keep the view on the last line; scrolling up turns it off, the icon turns it back on. */
+  follow: boolean;
+  status: LogcatStatus;
+  error: string | null;
+  lines: LogcatRow[];
+}
+
+export const useLogcat = create<LogcatState>(() => ({
+  devices: [],
+  devicesError: null,
+  loadingDevices: false,
+  serial: null,
+  level: "verbose",
+  query: "",
+  history: loadFilters(),
+  paused: false,
+  follow: true,
+  status: "idle",
+  error: null,
+  lines: [],
+}));
+
+/** Lines received while paused, applied on resume. */
+let pending: LogcatRow[] = [];
+
+/** Row ids keep growing: a reopened window's stale keys can never collide. */
+let nextId = 0;
+
+function push(lines: LogcatRow[], batch: LogcatRow[]): LogcatRow[] {
+  const next = lines.concat(batch);
+  return next.length > MAX_LINES ? next.slice(next.length - MAX_LINES) : next;
+}
+
+/**
+ * Applies a stream batch. While paused the lines wait in `pending` instead, so
+ * resuming shows what happened meanwhile rather than a hole.
+ */
+export function appendLines(batch: LogcatLine[]) {
+  const rows = batch.map((line) => ({ ...line, id: ++nextId }));
+  const { paused } = useLogcat.getState();
+  if (paused) {
+    pending = pending.concat(rows);
+    if (pending.length > MAX_LINES) pending = pending.slice(pending.length - MAX_LINES);
+    return;
+  }
+  useLogcat.setState((s) => ({ lines: push(s.lines, rows) }));
+}
+
+export function setPaused(paused: boolean) {
+  if (!paused && pending.length) {
+    const lines = pending;
+    pending = [];
+    useLogcat.setState((s) => ({ lines: push(s.lines, lines), paused }));
+    return;
+  }
+  useLogcat.setState({ paused });
+}
+
+export function clearLines() {
+  pending = [];
+  useLogcat.setState({ lines: [] });
+}
+
+/** Takes a fresh device list, keeping the watched device while it is still there. */
+export function setDevices(devices: AndroidDevice[]) {
+  const { serial } = useLogcat.getState();
+  const usable = (d: AndroidDevice) => d.state === "device";
+  const keep = serial !== null && devices.some((d) => d.serial === serial && usable(d));
+  useLogcat.setState({
+    devices,
+    devicesError: null,
+    loadingDevices: false,
+    serial: keep ? serial : (devices.find(usable)?.serial ?? null),
+  });
+}
+
+export function setDevicesError(message: string) {
+  useLogcat.setState({ devicesError: message, loadingDevices: false });
+}
+
+export function setStatus(status: LogcatStatus, error: string | null = null) {
+  useLogcat.setState({ status, error });
+}
+
+export function resetLogcat() {
+  pending = [];
+  useLogcat.setState({
+    devices: [],
+    devicesError: null,
+    loadingDevices: false,
+    serial: null,
+    paused: false,
+    status: "idle",
+    error: null,
+    lines: [],
+  });
+}
diff --git a/src/features/notebook/CellEditor.tsx b/src/features/notebook/CellEditor.tsx
index 627ea58ff..9089b89fa 100644
--- a/src/features/notebook/CellEditor.tsx
+++ b/src/features/notebook/CellEditor.tsx
@@ -12,6 +12,7 @@ import { defaultKeymap, indentWithTab } from "@codemirror/commands";
 import { bracketMatching, indentOnInput, syntaxHighlighting } from "@codemirror/language";
 import { openideaTheme } from "@/editor/core/cm/theme";
 import { openideaHighlightStyle } from "@/editor/core/cm/highlight";
+import { selectionMarks } from "@/editor/core/cm/selectionMarks";
 import { findLanguageDescription, loadSupport } from "@/editor/core/cm/languages";
 import { tx } from "@/platform/i18n";
 import type { NotebookSession } from "./session";
@@ -43,6 +44,7 @@ export function CellEditor({
       syntaxHighlighting(openideaHighlightStyle),
       lineNumbers(),
       drawSelection(),
+      selectionMarks,
       highlightActiveLine(),
       highlightSpecialChars(),
       bracketMatching(),
diff --git a/src/features/plugins/IntellijThemesDialog.tsx b/src/features/plugins/IntellijThemesDialog.tsx
index 7924b6396..2f683806a 100644
--- a/src/features/plugins/IntellijThemesDialog.tsx
+++ b/src/features/plugins/IntellijThemesDialog.tsx
@@ -1,12 +1,11 @@
 /**
- * Import Theme from IntelliJ IDE: the theme plugins installed in the JetBrains
- * IDEs on this machine, each under its plugin's heading, the plugin of the
- * theme in use first. Importing a theme brings every theme of its plugin, as
- * installing the plugin in IntelliJ does, and applies the chosen one
- * (`importIntellijTheme`). A file can be chosen instead.
+ * Import Theme from JetBrains IDE: the theme plugins installed in the JetBrains
+ * IDEs (and Android Studio) on this machine, one row per plugin of each IDE, the
+ * plugins of the themes in use first. Importing installs the plugin with all its
+ * themes, as installing it in the IDE does (`importIntellijTheme`); which theme
+ * to use stays a choice in Settings › Appearance. A file can be chosen instead.
  */
 import { useEffect, useState } from "react";
-import clsx from "clsx";
 import type { InstalledIntellijTheme } from "@/bindings";
 import { tx } from "@/platform/i18n";
 import { Badge, Dialog, List, Spinner, T } from "@/ui";
@@ -15,28 +14,30 @@ import { closeInstalledIntellijThemes, importIntellijTheme, useIntellijThemesDia
 import { errorText } from "./store";
 import styles from "./PluginsPage.module.css";
 
-type Row =
-  | { kind: "plugin"; key: string; plugin: string; ide: string; count: number; first: boolean }
-  | { kind: "theme"; key: string; theme: InstalledIntellijTheme };
+interface PluginRow {
+  key: string;
+  plugin: string;
+  ide: string;
+  path: string;
+  themes: InstalledIntellijTheme[];
+}
 
-/** A heading per plugin (of an IDE) with its themes under it, in the order found (the one in use first). */
-function themeRows(themes: readonly InstalledIntellijTheme[]): Row[] {
-  const plugins = new Map<string, InstalledIntellijTheme[]>();
+/** A row per plugin (of an IDE), in the order found (the one in use first). */
+function pluginRows(themes: readonly InstalledIntellijTheme[]): PluginRow[] {
+  const plugins = new Map<string, PluginRow>();
   for (const t of themes) {
     const key = `${t.ide}\n${t.path}`;
-    plugins.set(key, [...(plugins.get(key) ?? []), t]);
+    const row = plugins.get(key) ?? { key, plugin: t.plugin, ide: t.ide, path: t.path, themes: [] };
+    plugins.set(key, row);
+    row.themes.push(t);
   }
-  return [...plugins].flatMap(([key, list], i): Row[] => [
-    { kind: "plugin", key, plugin: list[0]!.plugin, ide: list[0]!.ide, count: list.length, first: i === 0 },
-    ...list.map((theme): Row => ({ kind: "theme", key: `${key}\n${theme.themeId}`, theme })),
-  ]);
+  return [...plugins.values()];
 }
 
 function IntellijThemesDialog() {
   const [themes, setThemes] = useState<InstalledIntellijTheme[] | null>(null);
   const [error, setError] = useState<string | null>(null);
-  // The first theme, under the first heading.
-  const [active, setActive] = useState(1);
+  const [active, setActive] = useState(0);
   useEffect(() => {
     let live = true;
     pluginsBackend()
@@ -54,50 +55,48 @@ function IntellijThemesDialog() {
     };
   }, []);
 
-  const run = (theme?: InstalledIntellijTheme) => {
+  const run = (path?: string) => {
     const { onImported } = useIntellijThemesDialog.getState();
     closeInstalledIntellijThemes();
-    void importIntellijTheme(theme?.path, theme?.themeId).then((id) => id && onImported?.(id));
+    void importIntellijTheme(path).then((id) => id && onImported?.(id));
   };
-  const rows = themeRows(themes ?? []);
-  const row = rows[active];
-  const chosen = row?.kind === "theme" ? row.theme : undefined;
+  const rows = pluginRows(themes ?? []);
+  const chosen = rows[active];
 
   return (
     <Dialog
       open
-      title="Import Theme from IntelliJ IDE"
+      title="Import Theme from JetBrains IDE"
       width={640}
       onClose={closeInstalledIntellijThemes}
       buttons={[
         { label: "Choose File…", role: "extra", onClick: () => run() },
         { label: "Cancel", role: "cancel" },
-        { label: "Import", role: "default", disabled: !chosen, onClick: () => chosen && run(chosen) },
+        { label: "Import", role: "default", disabled: !chosen, onClick: () => chosen && run(chosen.path) },
       ]}
     >
       <div className={styles.intellijThemes}>
         <p className={styles.muted}>
           <T>
-            Theme plugins installed in the JetBrains IDEs on this computer. Importing a theme brings every theme of its
-            plugin and applies the chosen one. Colours without an OpenIDEA counterpart keep the default theme colours.
+            Theme plugins installed in the JetBrains IDEs on this computer. Importing one installs it with all its
+            themes; choose the theme to use in Settings › Appearance. Colours without an OpenIDEA counterpart keep the
+            default theme colours.
           </T>
         </p>
         {themes === null ? (
           <div className={styles.intellijThemesStatus}>
-            <Spinner size={14} label="Looking for IntelliJ themes" />
-            <T>Looking for IntelliJ themes…</T>
+            <Spinner size={14} label="Looking for JetBrains themes" />
+            <T>Looking for JetBrains themes…</T>
           </div>
         ) : (
           <List
             items={rows}
             getKey={(r) => r.key}
-            isSection={(r) => r.kind === "plugin"}
             activeIndex={chosen ? active : -1}
             onActiveChange={setActive}
-            rowHeight={28}
-            sectionHeight={30}
+            rowHeight={44}
             className={styles.intellijThemesList}
-            aria-label={tx("IntelliJ themes")}
+            aria-label={tx("JetBrains theme plugins")}
             empty={
               <div className={styles.intellijThemesStatus} role="note">
                 {error ?? (
@@ -108,24 +107,21 @@ function IntellijThemesDialog() {
                 )}
               </div>
             }
-            renderSection={(r) =>
-              r.kind === "plugin" && (
-                <div className={clsx(styles.intellijPlugin, !r.first && styles.intellijPluginNext)}>
-                  <span className={styles.intellijPluginName}>{r.plugin}</span>
-                  <span>{r.count === 1 ? tx("1 theme") : tx`${r.count} themes`}</span>
-                  <span className={styles.intellijPluginIde}>{r.ide}</span>
+            renderItem={(r) => {
+              const count = r.themes.length;
+              return (
+                <div className={styles.intellijPlugin}>
+                  <div className={styles.intellijPluginHead}>
+                    <span className={styles.itemMain}>{r.plugin}</span>
+                    {r.themes.some((t) => t.active) && <Badge tone="accent">{tx("In use")}</Badge>}
+                    <span className={styles.intellijPluginIde}>
+                      {count === 1 ? tx("1 theme") : tx`${count} themes`} · {r.ide}
+                    </span>
+                  </div>
+                  <span className={styles.intellijPluginThemes}>{r.themes.map((t) => t.themeName).join(", ")}</span>
                 </div>
-              )
-            }
-            renderItem={(r) =>
-              r.kind === "theme" && (
-                <div className={styles.intellijTheme}>
-                  <span className={styles.itemMain}>{r.theme.themeName}</span>
-                  {r.theme.active && <Badge tone="accent">{tx("In use")}</Badge>}
-                  <span className={styles.muted}>{r.theme.dark ? tx("Dark") : tx("Light")}</span>
-                </div>
-              )
-            }
+              );
+            }}
           />
         )}
       </div>
diff --git a/src/features/plugins/PluginsPage.module.css b/src/features/plugins/PluginsPage.module.css
index 90b2c7398..dff2a73ef 100644
--- a/src/features/plugins/PluginsPage.module.css
+++ b/src/features/plugins/PluginsPage.module.css
@@ -407,37 +407,30 @@
   padding: 8px 10px;
   color: var(--fg-muted);
 }
-.intellijTheme {
-  display: flex;
-  flex: 1;
-  align-items: center;
-  gap: 8px;
-  min-width: 0;
-}
-.intellijTheme > .muted {
-  flex-shrink: 0;
-  font-size: var(--fs-small);
-}
 .intellijPlugin {
   display: flex;
   flex: 1;
-  align-items: center;
-  gap: 8px;
-  align-self: stretch;
+  flex-direction: column;
+  justify-content: center;
+  gap: 2px;
   min-width: 0;
 }
-/* A line above each plugin but the first, as in IDEA's Theme list. */
-.intellijPluginNext {
-  border-top: 1px solid var(--border);
+.intellijPluginHead {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  min-width: 0;
 }
-.intellijPluginName {
+.intellijPluginThemes {
   overflow: hidden;
-  color: var(--fg-secondary);
-  font-weight: 600;
+  color: var(--fg-muted);
+  font-size: var(--fs-small);
   text-overflow: ellipsis;
   white-space: nowrap;
 }
 .intellijPluginIde {
   flex-shrink: 0;
   margin-left: auto;
+  color: var(--fg-muted);
+  font-size: var(--fs-small);
 }
diff --git a/src/features/plugins/PluginsPage.tsx b/src/features/plugins/PluginsPage.tsx
index 7c66e6c15..ee094df84 100644
--- a/src/features/plugins/PluginsPage.tsx
+++ b/src/features/plugins/PluginsPage.tsx
@@ -569,7 +569,7 @@ function gearMenu(plugins: readonly PluginInfo[], updates: number, actions: Gear
     ...(actions.canImport
       ? [
           { kind: "separator" as const },
-          { label: "Import Theme from IntelliJ IDE…", run: actions.importInstalledIntellij },
+          { label: "Import Theme from JetBrains IDE…", run: actions.importInstalledIntellij },
           { label: "Import IntelliJ Theme from File…", run: actions.importIntellijFile },
         ]
       : []),
diff --git a/src/features/plugins/__tests__/intellijImport.test.tsx b/src/features/plugins/__tests__/intellijImport.test.tsx
index 21b8ac293..8f6754f8f 100644
--- a/src/features/plugins/__tests__/intellijImport.test.tsx
+++ b/src/features/plugins/__tests__/intellijImport.test.tsx
@@ -41,6 +41,15 @@ const INSTALLED: InstalledIntellijTheme[] = [
     dark: true,
     active: false,
   },
+  {
+    ide: "DataGrip 2026.2",
+    plugin: "Night Owl",
+    path: "/dg/plugins/NightOwl",
+    themeId: "owl-id",
+    themeName: "Night Owl",
+    dark: true,
+    active: false,
+  },
 ];
 
 let notes: Note[];
@@ -100,8 +109,8 @@ afterEach(() => {
 });
 
 describe("IntelliJ theme import", () => {
-  it("installs the converted plugin through the install page and applies the chosen theme", async () => {
-    expect(await importIntellijTheme("/downloads/DeepSea.zip", "shallow-id")).toBe(ID);
+  it("installs the converted plugin through the install page and leaves the theme in use as it is", async () => {
+    expect(await importIntellijTheme("/downloads/DeepSea.zip")).toBe(ID);
     expect(read).toHaveBeenCalledWith("/downloads/DeepSea.zip");
     const [name, files] = stage.mock.calls[0]!;
     expect(name).toBe(ID);
@@ -111,14 +120,11 @@ describe("IntelliJ theme import", () => {
       "themes/shallow.theme.json",
     ]);
     expect(installed).toEqual(["/app/plugins/.downloads/generated"]);
-    expect(useThemeOverride.getState().theme).toBe(`plugin:${ID}/shallow`);
+    // Which of its themes to use is the user's choice.
+    expect(useThemeOverride.getState().theme).toBeNull();
   });
 
-  it("applies the first theme without a choice, and nothing when the install is declined", async () => {
-    expect(await importIntellijTheme("/downloads/DeepSea.jar")).toBe(ID);
-    expect(useThemeOverride.getState().theme).toBe(`plugin:${ID}/deep-sea`);
-
-    useThemeOverride.setState({ theme: null });
+  it("returns nothing when the install is declined", async () => {
     setConsentPrompt(async () => null);
     expect(await importIntellijTheme("/downloads/DeepSea.jar")).toBeNull();
     expect(useThemeOverride.getState().theme).toBeNull();
@@ -152,33 +158,33 @@ describe("IntelliJ theme import", () => {
   });
 });
 
-describe("Import Theme from IntelliJ IDE", () => {
-  it("lists the installed themes by plugin, the one in use first, and imports the chosen one", async () => {
+describe("Import Theme from JetBrains IDE", () => {
+  it("lists one row per theme plugin, the one in use first, and imports the chosen plugin", async () => {
     const user = userEvent.setup();
     const onImported = vi.fn();
     render(<IntellijThemesDialogHost />);
     act(() => showInstalledIntellijThemes(onImported));
-    const list = await screen.findByRole("listbox", { name: "IntelliJ themes" });
+    const list = await screen.findByRole("listbox", { name: "JetBrains theme plugins" });
     const options = await waitFor(() => {
       const found = Array.from(list.querySelectorAll('[role="option"]'));
       expect(found).toHaveLength(2);
       return found;
     });
-    // Both under their plugin's heading: importing one brings the plugin's every theme.
-    expect(within(list).getByText("Deep Sea Themes")).toBeInTheDocument();
-    expect(within(list).getByText("2 themes")).toBeInTheDocument();
-    expect(within(list).getByText("IntelliJ IDEA 2025.2")).toBeInTheDocument();
-    expect(options[0]).toHaveTextContent("Shallow");
+    // A plugin brings all its themes: they are listed in its row, not offered one by one.
+    expect(options[0]).toHaveTextContent("Deep Sea Themes");
     expect(options[0]).toHaveTextContent("In use");
-    expect(options[1]).toHaveTextContent("Deep Sea");
+    expect(options[0]).toHaveTextContent("2 themes · IntelliJ IDEA 2025.2");
+    expect(options[0]).toHaveTextContent("Shallow, Deep Sea");
+    expect(options[1]).toHaveTextContent("Night Owl");
+    expect(options[1]).toHaveTextContent("1 theme · DataGrip 2026.2");
     expect(options[1]).not.toHaveTextContent("In use");
 
-    await user.click(screen.getByText("Deep Sea"));
+    await user.click(within(list).getByText("1 theme · DataGrip 2026.2"));
     await user.click(screen.getByRole("button", { name: "Import" }));
     await waitFor(() => expect(onImported).toHaveBeenCalledWith(ID));
-    expect(read).toHaveBeenCalledWith("/ij/plugins/DeepSea");
-    expect(useThemeOverride.getState().theme).toBe(`plugin:${ID}/deep-sea`);
-    expect(screen.queryByRole("listbox", { name: "IntelliJ themes" })).toBeNull();
+    expect(read).toHaveBeenCalledWith("/dg/plugins/NightOwl");
+    expect(useThemeOverride.getState().theme).toBeNull();
+    expect(screen.queryByRole("listbox", { name: "JetBrains theme plugins" })).toBeNull();
   });
 
   it("offers a file when no IDE has theme plugins", async () => {
diff --git a/src/features/plugins/__tests__/plugins.test.tsx b/src/features/plugins/__tests__/plugins.test.tsx
index 72b65f4b9..7828bb399 100644
--- a/src/features/plugins/__tests__/plugins.test.tsx
+++ b/src/features/plugins/__tests__/plugins.test.tsx
@@ -464,9 +464,17 @@ describe("bridge events", () => {
     expect(useTasks.getState().tasks.find((t) => t.id === "plugin:7")?.done).toBe(true);
   });
 
-  it("shows plugin notifications and tracks theme changes", () => {
+  it("shows plugin notifications, copies to clipboard, opens URLs and tracks theme changes", () => {
+    const writeText = vi.fn().mockResolvedValue(undefined);
+    Object.defineProperty(navigator, "clipboard", { value: { writeText }, configurable: true });
+    const open = vi.spyOn(window, "open").mockImplementation(() => null);
     handlePluginEvent({ type: "notification", pluginId: "p", level: "info", title: "Done", body: "3 words" });
     expect(notes).toEqual([{ group: "plugins", level: "info", title: "Done", body: "3 words" }]);
+    handlePluginEvent({ type: "copyToClipboard", pluginId: "p", text: "https://github.com/o/r" });
+    expect(writeText).toHaveBeenCalledWith("https://github.com/o/r");
+    handlePluginEvent({ type: "openUrl", pluginId: "p", url: "https://github.com/o/r/blob/main/a.rs" });
+    expect(open).toHaveBeenCalledWith("https://github.com/o/r/blob/main/a.rs", "_blank", "noopener");
+    open.mockRestore();
     handlePluginEvent({ type: "themeChanged", theme: null });
     expect(usePlugins.getState().activeTheme).toBeNull();
   });
@@ -509,7 +517,7 @@ describe("PluginsPage", () => {
     );
     const imports = async () => {
       await user.click(screen.getByRole("button", { name: "Manage Plugins" }));
-      const found = ["Import Theme from IntelliJ IDE…", "Import IntelliJ Theme from File…"].filter((name) =>
+      const found = ["Import Theme from JetBrains IDE…", "Import IntelliJ Theme from File…"].filter((name) =>
         screen.queryByRole("menuitem", { name }),
       );
       act(() => hideContextMenu());
diff --git a/src/features/plugins/index.ts b/src/features/plugins/index.ts
index 57e1c11a0..e659b68ec 100644
--- a/src/features/plugins/index.ts
+++ b/src/features/plugins/index.ts
@@ -113,10 +113,19 @@ export function activate(): () => void {
       },
       {
         id: "plugins.importInstalledIntellijTheme",
-        title: "Import Theme from IntelliJ IDE…",
+        title: "Import Theme from JetBrains IDE…",
         category: "Plugins",
         icon: "plugin",
-        keywords: ["intellij", "jetbrains", "theme", "color scheme", "migrate"],
+        keywords: [
+          "intellij",
+          "jetbrains",
+          "pycharm",
+          "webstorm",
+          "android studio",
+          "theme",
+          "color scheme",
+          "migrate",
+        ],
         when: "projectOpen",
         run: () => showInstalledIntellijThemes(),
       },
diff --git a/src/features/plugins/intellijImport.ts b/src/features/plugins/intellijImport.ts
index 3ba281f78..8a0f9f5aa 100644
--- a/src/features/plugins/intellijImport.ts
+++ b/src/features/plugins/intellijImport.ts
@@ -2,30 +2,26 @@
  * Settings › Plugins › Import IntelliJ Theme: an IntelliJ theme plugin (a
  * Marketplace `.jar` / `.zip`, a plugin folder of an installed IDE) or a
  * `.theme.json` becomes an OpenIDEA theme plugin — read by the host, converted
- * here (`intellijTheme.ts`), installed through the usual install page — and
- * its theme is applied.
+ * here (`intellijTheme.ts`), installed through the usual install page. Its
+ * themes join the others; which one to use is chosen in Settings › Appearance.
  */
 import { create } from "zustand";
-import { pluginThemeRef } from "@/platform/themes";
 import { notifications } from "@/workbench/contributions";
-import { setTheme } from "@/workbench/theme";
 import { pluginsBackend } from "./backend";
-import { intellijThemePackage, type ThemePackage } from "./intellijTheme";
+import { intellijThemePackage } from "./intellijTheme";
 import { errorText, installFromDisk } from "./store";
 
 /**
- * Imports the IntelliJ theme plugin at `path` (asks for a file without one)
- * and applies its theme `themeId` (an IntelliJ theme id), or its first.
- * Returns the installed plugin's id.
+ * Imports the IntelliJ theme plugin at `path` (asks for a file without one).
+ * Returns the installed plugin's id; the theme in use stays as it is.
  */
-export async function importIntellijTheme(path?: string, themeId?: string): Promise<string | null> {
+export async function importIntellijTheme(path?: string): Promise<string | null> {
   const backend = pluginsBackend();
-  let pkg: ThemePackage;
   let dir: string;
   try {
     const picked = path ?? (await backend.pickIntellijTheme());
     if (!picked) return null;
-    pkg = intellijThemePackage(await backend.readIntellijTheme(picked));
+    const pkg = intellijThemePackage(await backend.readIntellijTheme(picked));
     dir = await backend.stagePackage(pkg.id, pkg.files);
   } catch (e) {
     notifications().notify({
@@ -36,11 +32,7 @@ export async function importIntellijTheme(path?: string, themeId?: string): Prom
     });
     return null;
   }
-  const id = await installFromDisk(dir);
-  if (!id) return null;
-  const theme = pkg.themes.find((t) => t.sourceId === themeId) ?? pkg.themes[0];
-  if (theme) await setTheme(pluginThemeRef(id, theme.id));
-  return id;
+  return installFromDisk(dir);
 }
 
 interface DialogState {
diff --git a/src/features/plugins/intellijTheme.ts b/src/features/plugins/intellijTheme.ts
index 963b80efe..33650dfb3 100644
--- a/src/features/plugins/intellijTheme.ts
+++ b/src/features/plugins/intellijTheme.ts
@@ -384,8 +384,6 @@ export interface ThemePackage {
   id: string;
   name: string;
   files: { path: string; text: string }[];
-  /** The package's themes: their id here and in the IntelliJ plugin (`sourceId`). */
-  themes: { id: string; sourceId: string; name: string }[];
 }
 
 /** `2.3` → `2.3.0`; IntelliJ plugin versions are not always semver. */
@@ -397,16 +395,15 @@ function semver(version: string | null): string {
 /** An OpenIDEA theme plugin (`intellij.<plugin>`) with every theme of an IntelliJ theme plugin. */
 export function intellijThemePackage(source: IntellijThemeSource): ThemePackage {
   const ids = new Set<string>();
-  const converted = source.themes.map((t) => {
+  const themes = source.themes.map((t) => {
     const c = convertIntellijTheme(t.theme, t.editorScheme ?? undefined);
     let id = c.theme.id;
     for (let n = 2; ids.has(id); n++) id = `${c.theme.id.slice(0, 44)}-${n}`;
     ids.add(id);
     c.theme.id = id;
-    return { sourceId: t.id, converted: c };
+    return c;
   });
-  if (converted.length === 0) throw new Error("The plugin has no themes");
-  const themes = converted.map((c) => c.converted);
+  if (themes.length === 0) throw new Error("The plugin has no themes");
   // Package metadata, not UI text: the plugin list shows it as written.
   const description = `${source.name}, imported from an IntelliJ theme plugin.`;
   const info: ThemePackageInfo = {
@@ -427,6 +424,5 @@ export function intellijThemePackage(source: IntellijThemeSource): ThemePackage
         ...(c.scheme ? [{ path: `themes/${c.theme.id}.scheme.json`, text: json(c.scheme) }] : []),
       ]),
     ],
-    themes: converted.map(({ sourceId, converted: c }) => ({ id: c.theme.id, sourceId, name: c.theme.name })),
   };
 }
diff --git a/src/features/plugins/runtimeUi.tsx b/src/features/plugins/runtimeUi.tsx
index c0b7efd0d..f8de39bfa 100644
--- a/src/features/plugins/runtimeUi.tsx
+++ b/src/features/plugins/runtimeUi.tsx
@@ -9,6 +9,7 @@ import type { EventKind, PluginEvent, StatusItem, WorkbenchEvent } from "@/bindi
 import { onEditorEvent } from "@/editor/api";
 import { executeAction, getAction, onActionExecuted } from "@/platform/actions";
 import { onIdeEvent } from "@/platform/ipc";
+import { openExternalUrl } from "@/platform/openUrl";
 import { useProject } from "@/platform/project";
 import { shortcutLabel } from "@/platform/keymap";
 import { BarButton } from "@/ui/BarButton";
@@ -262,6 +263,12 @@ export function handleRuntimeEvent(e: PluginEvent): boolean {
     case "openLocation":
       void maybeEditorService()?.openFile(e.path, { selection: { line: e.line, col: e.column }, focus: true });
       return true;
+    case "copyToClipboard":
+      void navigator.clipboard?.writeText(e.text);
+      return true;
+    case "openUrl":
+      void openExternalUrl(e.url);
+      return true;
     default:
       return false;
   }
diff --git a/src/features/project-tree/fs.test.ts b/src/features/project-tree/fs.test.ts
index 017cef334..18327b4b2 100644
--- a/src/features/project-tree/fs.test.ts
+++ b/src/features/project-tree/fs.test.ts
@@ -13,7 +13,13 @@ vi.mock("@/platform/tauriCore", async (original) => ({
 beforeEach(() => {
   useTasks.setState({ tasks: [] });
   useRemote.setState({
-    session: { sshConfig: "s", root: "/remote", host: "host", commands: ["fs_copy", "cancel_request"] },
+    session: {
+      target: { kind: "ssh", config: "s" },
+      root: "/remote",
+      host: "host",
+      os: "linux",
+      commands: ["fs_copy", "cancel_request"],
+    },
   });
 });
 afterEach(() => {
diff --git a/src/features/project-tree/index.ts b/src/features/project-tree/index.ts
index bbe46457b..87284c5cd 100644
--- a/src/features/project-tree/index.ts
+++ b/src/features/project-tree/index.ts
@@ -116,9 +116,13 @@ export function activate(): () => void {
     const paths = own ? validateProjectStructure(settings?.projectStructure).contentRoots : [];
     // The Build tool window's model (one load per build change), not a load of our own.
     const build = useBuildModel.getState();
-    const gradleProjects = build.root === project?.root ? (build.model?.gradle?.projects ?? []) : [];
-    const rootName = gradleProjects.find((p) => p.path === ":")?.name ?? "";
-    const groups = own && project ? gradleModuleGroups(gradleProjects, rootName, project.root) : [];
+    const gradleBuilds = build.root === project?.root ? (build.model?.gradle ?? []) : [];
+    const groups =
+      own && project
+        ? gradleBuilds.flatMap((g) =>
+            gradleModuleGroups(g.projects, g.projects.find((p) => p.path === ":")?.name ?? "", project.root, g.dir),
+          )
+        : [];
     const key = JSON.stringify([paths, groups]);
     if (key === shownRoots) return;
     shownRoots = key;
diff --git a/src/features/project-tree/moduleGroups.test.ts b/src/features/project-tree/moduleGroups.test.ts
index c7d70ae28..b2481bcaa 100644
--- a/src/features/project-tree/moduleGroups.test.ts
+++ b/src/features/project-tree/moduleGroups.test.ts
@@ -123,3 +123,15 @@ describe("module group nodes in the tree", () => {
     expect(m.children.get(m.roots[0]!.key)!.map((n) => n.label)).toEqual(["billing", "core"]);
   });
 });
+
+it("namespaces module group identities by independently linked build", () => {
+  const projects = [
+    { path: ":", dir: "/w/first" },
+    { path: ":app", dir: "/w/shared" },
+  ];
+  const first = gradleModuleGroups(projects, "same", "/w/project", "first");
+  const second = gradleModuleGroups(projects, "same", "/w/project", "second");
+  expect(first.length).toBeGreaterThan(0);
+  expect(first[0]!.id).not.toBe(second[0]!.id);
+  expect(first.map(shape)).toEqual(second.map(shape));
+});
diff --git a/src/features/project-tree/moduleGroups.ts b/src/features/project-tree/moduleGroups.ts
index 40a178f72..a3e485720 100644
--- a/src/features/project-tree/moduleGroups.ts
+++ b/src/features/project-tree/moduleGroups.ts
@@ -29,7 +29,9 @@ export function gradleModuleGroups(
   projects: readonly { path: string; dir: string; build?: string | null }[],
   rootName: string,
   projectRoot: string,
+  buildDir?: string,
 ): ExtraRoot[] {
+  const identity = (name: string) => (buildDir === undefined ? name : JSON.stringify([buildDir, name]));
   const modules: Module[] = projects.map((p) => {
     const path = p.path.split(":").filter(Boolean);
     // An included build's modules are named after that build (`lib.core`); buildSrc and
@@ -51,7 +53,13 @@ export function gradleModuleGroups(
 
   const moduleNode = (m: Module): ExtraRoot => {
     const label = nameOf(m.dir) || m.dir;
-    return { id: m.name, label, detail: m.name === label ? undefined : m.name, icon: "gradle-module", path: m.dir };
+    return {
+      id: identity(m.name),
+      label,
+      detail: m.name === label ? undefined : m.name,
+      icon: "gradle-module",
+      path: m.dir,
+    };
   };
   // `modulesAndGroups`: ungrouped top-level modules as they are (the project folder is
   // shown anyway), one node for the common group path of the grouped ones.
@@ -82,7 +90,7 @@ export function gradleModuleGroups(
     const seen = new Set<string>();
     const moduleNodes = members.filter((m) => !seen.has(m.dir) && !!seen.add(m.dir)).map(moduleNode);
     return {
-      id: `gradleGroup:${group.join(".")}`,
+      id: identity(`gradleGroup:${group.join(".")}`),
       label: group[group.length - 1]!,
       icon: "gradle-project",
       children: [...[...childGroups.values()].map(node).sort(byLabel), ...moduleNodes.sort(byLabel)],
diff --git a/src/features/project-tree/operations.test.ts b/src/features/project-tree/operations.test.ts
index 2204d9984..46cdc104f 100644
--- a/src/features/project-tree/operations.test.ts
+++ b/src/features/project-tree/operations.test.ts
@@ -2,6 +2,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { MEMBER_PREFIX, type ProjectNode } from "./model";
 import {
   canPaste,
+  checkEditingName,
   copySelection,
   importExternal,
   paste,
@@ -13,6 +14,7 @@ import {
 import { IpcError } from "@/platform/ipc";
 import { closeFileRefactorDialog, pendingFileRefactorDialog } from "./FileRefactorDialogs";
 import { useRemote } from "@/platform/remote";
+import { usePlatform } from "@/platform/platformInfo";
 import { provideNotificationService } from "@/workbench/contributions";
 import { MemoryFs, setProjectFsForTests } from "./fs";
 import { initProjectTree, loadDir, setClipboard, setSelection, useProjectTree } from "./store";
@@ -21,6 +23,30 @@ import { setOsClipboardForTests } from "./clipboard";
 let fs: MemoryFs;
 const notify = vi.fn();
 
+describe("file names follow the execution host", () => {
+  const platform = usePlatform.getState();
+  afterEach(() => {
+    usePlatform.setState(platform);
+    useRemote.setState({ session: null });
+    setProjectFsForTests(null);
+    initProjectTree(null);
+  });
+
+  it.each(["linux", "windows", "macos"])("validates names on a %s host from a Windows desktop", async (os) => {
+    usePlatform.setState({ os: "windows" });
+    useRemote.setState({
+      session: { target: { kind: "ssh", config: "host" }, root: "/p", host: "host", os, commands: [] },
+    });
+    fs = new MemoryFs({ "/p/readme.txt": "" }, "/p");
+    setProjectFsForTests(fs, "/p");
+    initProjectTree("/p", "p");
+    await loadDir("/p");
+    useProjectTree.setState({ editing: { kind: "new", parent: "/p", nodeKind: "file" } });
+    expect(checkEditingName("con").error !== null).toBe(os === "windows");
+    expect(checkEditingName("README.txt").error !== null).toBe(os !== "linux");
+  });
+});
+
 const node = (path: string, dir = false): ProjectNode => ({
   key: path,
   path,
@@ -102,7 +128,9 @@ describe("OS file imports", () => {
     setProjectFsForTests(fs, "/p");
     initProjectTree("/p", "p");
     await loadDir("/p");
-    useRemote.setState({ session: { sshConfig: "ssh", root: "/p", host: "host", commands: ["fs_copy"] } });
+    useRemote.setState({
+      session: { target: { kind: "ssh", config: "ssh" }, root: "/p", host: "host", os: "linux", commands: ["fs_copy"] },
+    });
     provideNotificationService({ notify });
     notify.mockClear();
   });
@@ -292,7 +320,15 @@ describe("project clipboard ownership", () => {
   it.each(remoteCases)(
     "remote hand-off=$handedOff OS=$osList cut=$cut on $entry",
     async ({ handedOff, osList, cut, entry }) => {
-      useRemote.setState({ session: { sshConfig: "ssh", root: "/p", host: "host", commands: ["fs_copy"] } });
+      useRemote.setState({
+        session: {
+          target: { kind: "ssh", config: "ssh" },
+          root: "/p",
+          host: "host",
+          os: "linux",
+          commands: ["fs_copy"],
+        },
+      });
       const writeText = vi.fn(async () => {
         if (!handedOff) throw new Error("unavailable");
       });
@@ -338,7 +374,9 @@ describe("project clipboard ownership", () => {
   );
 
   it("writes multiple remote paths as newline-joined text", async () => {
-    useRemote.setState({ session: { sshConfig: "ssh", root: "/p", host: "host", commands: ["fs_copy"] } });
+    useRemote.setState({
+      session: { target: { kind: "ssh", config: "ssh" }, root: "/p", host: "host", os: "linux", commands: ["fs_copy"] },
+    });
     await fs.createFile("/p/second.txt");
     await loadDir("/p", true);
     setSelection(new Set(["/p/source.txt", "/p/second.txt"]), "/p/source.txt");
@@ -350,7 +388,9 @@ describe("project clipboard ownership", () => {
   });
 
   it("waits for a pending remote text write before reading file URLs", async () => {
-    useRemote.setState({ session: { sshConfig: "ssh", root: "/p", host: "host", commands: ["fs_copy"] } });
+    useRemote.setState({
+      session: { target: { kind: "ssh", config: "ssh" }, root: "/p", host: "host", os: "linux", commands: ["fs_copy"] },
+    });
     let finish!: () => void;
     vi.stubGlobal("navigator", {
       clipboard: {
diff --git a/src/features/project-tree/operations.ts b/src/features/project-tree/operations.ts
index b34122fd7..410421af0 100644
--- a/src/features/project-tree/operations.ts
+++ b/src/features/project-tree/operations.ts
@@ -39,17 +39,14 @@ import {
   useProjectTree,
 } from "./store";
 import { tx } from "@/platform/i18n";
-import { isRemoteWindow } from "@/platform/remote";
+import { hostOs, isRemoteWindow } from "@/platform/remote";
+import { usePlatform } from "@/platform/platformInfo";
 
 /** Nodes that may be renamed, moved or deleted (not roots, groups or library sources). */
 const mutable = (n: ProjectNode) => !n.root && !n.placeholder && !n.readOnly;
 
 const get = () => useProjectTree.getState();
-
-const ua = typeof navigator !== "undefined" ? navigator.userAgent : "";
-const isWindows = /Win/i.test(ua);
-/** macOS and Windows file systems are case-insensitive by default. */
-const caseInsensitive = /Mac|Win/i.test(ua);
+const caseInsensitiveOs = (os: string) => os === "windows" || os === "macos";
 
 function errorMessage(e: unknown): string {
   return e instanceof Error ? e.message : String(e);
@@ -236,6 +233,9 @@ export function cancelEditing() {
 export function checkEditingName(name: string) {
   const { editing } = get();
   if (!editing) return { error: null };
+  const os = hostOs();
+  const isWindows = os === "windows";
+  const caseInsensitive = caseInsensitiveOs(os);
   if (editing.kind === "new" && editing.pkg) {
     const { segments, error } = packageSegments(name, editing.pkg);
     if (!segments) return { error };
@@ -645,6 +645,7 @@ async function pasteFromOsClipboard(paths: string[], target: string) {
 /** The same files, as the clipboard keeps them (`/`-separated, any order). */
 function sameFiles(files: string[], paths: string[] | undefined): boolean {
   if (!paths || files.length !== paths.length) return false;
+  const caseInsensitive = caseInsensitiveOs(usePlatform.getState().os);
   const key = (list: string[]) =>
     list
       .map((p) => (caseInsensitive ? p.toLowerCase() : p))
@@ -687,6 +688,7 @@ export async function transfer(
   if (!root) return false;
   const fs = projectFs(root);
   await loadDir(target);
+  const caseInsensitive = caseInsensitiveOs(hostOs());
   const taken = new Set(siblingsOf(target).map((n) => (caseInsensitive ? n.toLowerCase() : n)));
   const hasName = (n: string) => taken.has(caseInsensitive ? n.toLowerCase() : n);
   const isTaken = (n: string) => hasName(n) || (isUnityAssetFolder(target) && hasName(`${n}.meta`));
@@ -744,6 +746,7 @@ export async function transfer(
 async function moveInto(paths: string[], target: string): Promise<boolean> {
   paths = assetPaths(paths);
   await loadDir(target);
+  const caseInsensitive = caseInsensitiveOs(hostOs());
   const taken = new Set(siblingsOf(target).map((n) => (caseInsensitive ? n.toLowerCase() : n)));
   const errors: string[] = [];
   const moves: { from: string; to: string }[] = [];
diff --git a/src/features/remote-dev/ConnectDialog.test.tsx b/src/features/remote-dev/ConnectDialog.test.tsx
index dbfed1b16..bba3c8d3d 100644
--- a/src/features/remote-dev/ConnectDialog.test.tsx
+++ b/src/features/remote-dev/ConnectDialog.test.tsx
@@ -6,8 +6,9 @@ import { useRemoteProgress } from "@/platform/remote";
 import { ConnectHost } from "./ConnectDialog";
 import { closeConnectDialog, openConnectDialog, useConnectDialog } from "./model";
 
-const { list, globalSettings, openRemote, executeAction } = vi.hoisted(() => ({
+const { list, distros, globalSettings, openRemote, executeAction } = vi.hoisted(() => ({
   list: vi.fn(),
+  distros: vi.fn(),
   globalSettings: vi.fn(),
   openRemote: vi.fn(),
   executeAction: vi.fn(),
@@ -15,7 +16,10 @@ const { list, globalSettings, openRemote, executeAction } = vi.hoisted(() => ({
 
 vi.mock("@/platform/ipc", async (importOriginal) => {
   const real = await importOriginal<typeof import("@/platform/ipc")>();
-  return { ...real, commands: { ...real.commands, remoteBootstrapList: list, settingsGetGlobal: globalSettings } };
+  return {
+    ...real,
+    commands: { ...real.commands, remoteBootstrapList: list, wslDistros: distros, settingsGetGlobal: globalSettings },
+  };
 });
 vi.mock("@/workbench/projectWindow", () => ({ openRemoteProject: openRemote }));
 vi.mock("@/platform/actions", async (importOriginal) => ({
@@ -35,6 +39,7 @@ const entry = (path: string, isDir = true): RemoteEntry => ({
 
 beforeEach(() => {
   vi.resetAllMocks();
+  distros.mockResolvedValue({ status: "ok", data: [] });
   // A remote project's window: its settings are the remote host's, without this machine's SSH configurations.
   useProject.setState({ project: null, opening: false, settings: { ssh: { configs: [] } } as unknown as Settings });
   globalSettings.mockResolvedValue({
@@ -87,7 +92,9 @@ it("browses the selected SSH host, navigates folders and opens one without a cur
   await waitFor(() => expect(screen.getByLabelText("Project directory:")).toHaveValue("/home/dev/projects"));
   expect(within(folders).getAllByRole("button")).toHaveLength(1);
   fireEvent.click(screen.getByRole("button", { name: "Open" }));
-  await waitFor(() => expect(openRemote).toHaveBeenCalledWith("selected", "/home/dev/projects"));
+  await waitFor(() =>
+    expect(openRemote).toHaveBeenCalledWith({ kind: "ssh", config: "selected" }, "/home/dev/projects"),
+  );
   expect(useConnectDialog.getState().open).toBe(false);
   expect(useProject.getState().project).toBeNull();
 });
@@ -125,3 +132,24 @@ it("offers SSH configuration and disables Browse until one exists, then lists th
   await waitFor(() => expect(screen.getByRole("button", { name: "Browse" })).toBeEnabled());
   expect(screen.getByRole("button", { name: "SSH configuration" })).toHaveTextContent("dev");
 });
+
+it("hides the WSL choice when no distribution is installed", async () => {
+  render(<ConnectHost />);
+  await waitFor(() => expect(distros).toHaveBeenCalled());
+  expect(screen.queryByRole("button", { name: "Connect through" })).toBeNull();
+});
+
+it("opens a folder of the chosen WSL distribution, without browsing over SFTP", async () => {
+  const installed = ["Ubuntu-24.04", "Debian"];
+  distros.mockResolvedValue({ status: "ok", data: installed });
+  openRemote.mockResolvedValue(true);
+  render(<ConnectHost />);
+  fireEvent.click(await screen.findByRole("button", { name: "Connect through" }));
+  fireEvent.click(screen.getByRole("option", { name: "WSL" }));
+  expect(screen.queryByRole("button", { name: "Browse" })).toBeNull();
+  fireEvent.click(screen.getByRole("button", { name: "WSL distribution" }));
+  fireEvent.click(screen.getByRole("option", { name: installed[1] }));
+  fireEvent.click(screen.getByRole("button", { name: "Open" }));
+  await waitFor(() => expect(openRemote).toHaveBeenCalledWith({ kind: "wsl", distro: installed[1] }, "~"));
+  expect(list).not.toHaveBeenCalled();
+});
diff --git a/src/features/remote-dev/ConnectDialog.tsx b/src/features/remote-dev/ConnectDialog.tsx
index 35df2afa2..f662b831c 100644
--- a/src/features/remote-dev/ConnectDialog.tsx
+++ b/src/features/remote-dev/ConnectDialog.tsx
@@ -2,7 +2,7 @@
 import { useEffect, useState } from "react";
 import { executeAction } from "@/platform/actions";
 import { useTx } from "@/platform/i18n";
-import { call, commands, isCancelled, onIdeEvent, type RemoteEntry } from "@/platform/ipc";
+import { call, commands, isCancelled, onIdeEvent, type RemoteEntry, type RemoteTarget } from "@/platform/ipc";
 import { useRemoteProgress } from "@/platform/remote";
 import { sshLabel, type SshConfigValid, validateRemote } from "@/platform/remoteSettings";
 import { Button, Dialog, Icon, Input, ProgressBar, Select, Spinner } from "@/ui";
@@ -52,11 +52,34 @@ function ConnectDialog() {
   const configs = useLocalSshConfigs();
   const [picked, setSsh] = useState("");
   const ssh = configs.some((c) => c.id === picked) ? picked : (configs[0]?.id ?? "");
+  const [kind, setKind] = useState<RemoteTarget["kind"]>("ssh");
+  // Installed WSL distributions; none (or no WSL at all) hides the WSL choice.
+  const [distros, setDistros] = useState<string[]>([]);
+  const [distro, setDistro] = useState("");
   const [path, setPath] = useState("~");
   const [busy, setBusy] = useState(false);
   const [error, setError] = useState<string | null>(null);
   const [browse, setBrowse] = useState<{ dir: string; folders: RemoteEntry[] } | null>(null);
 
+  useEffect(() => {
+    let live = true;
+    // Detection is a convenience: any failure just leaves SSH as the only choice.
+    void call(commands.wslDistros())
+      .then((found) => {
+        if (!live) return;
+        setDistros(found);
+        setDistro((d) => d || (found[0] ?? ""));
+      })
+      .catch(() => {});
+    return () => {
+      live = false;
+    };
+  }, []);
+
+  const wsl = kind === "wsl";
+  const name = wsl ? distro : ssh;
+  const target: RemoteTarget = wsl ? { kind: "wsl", distro } : { kind: "ssh", config: ssh };
+
   const list = async (dir: string) => {
     setError(null);
     setBusy(true);
@@ -76,8 +99,7 @@ function ConnectDialog() {
     setError(null);
     setBusy(true);
     try {
-      const target = path.trim() || "~";
-      if (await openRemoteProject(ssh, target)) closeConnectDialog();
+      if (await openRemoteProject(target, path.trim() || "~")) closeConnectDialog();
       else setBusy(false);
     } catch (e) {
       if (!isCancelled(e)) setError(e instanceof Error ? e.message : String(e));
@@ -86,7 +108,7 @@ function ConnectDialog() {
   };
 
   const options = configs.map((c) => ({ value: c.id, label: c.name.trim() || sshLabel(c), detail: sshLabel(c) }));
-  const ready = !!ssh && !busy && !!path.trim();
+  const ready = !!name && !busy && !!path.trim();
   const connecting = useRemoteProgress((s) => s.progress !== null);
 
   return (
@@ -115,21 +137,52 @@ function ConnectDialog() {
         <p className={styles.hint}>
           {tx("The project runs on the remote host; the IDE backend is installed there on first use.")}
         </p>
-        <label className={styles.label}>{tx("SSH configuration:")}</label>
-        <div className={styles.row}>
-          <Select
-            className={styles.grow}
-            value={ssh || null}
-            options={options}
-            placeholder={tx("No SSH configurations")}
-            onChange={(id) => {
-              setSsh(id);
-              setBrowse(null);
-            }}
-            aria-label={tx("SSH configuration")}
-          />
-          <Button onClick={() => void executeAction("file.settings", SSH_SETTINGS_PAGE)}>{tx("Configure…")}</Button>
-        </div>
+        {distros.length > 0 && (
+          <>
+            <label className={styles.label}>{tx("Connect through:")}</label>
+            <Select
+              value={kind}
+              options={[
+                { value: "ssh", label: "SSH" },
+                { value: "wsl", label: "WSL" },
+              ]}
+              onChange={(k) => {
+                setKind(k as RemoteTarget["kind"]);
+                setBrowse(null);
+              }}
+              aria-label={tx("Connect through")}
+            />
+          </>
+        )}
+        {wsl ? (
+          <>
+            <label className={styles.label}>{tx("WSL distribution:")}</label>
+            <Select
+              value={distro || null}
+              options={distros.map((d) => ({ value: d, label: d }))}
+              onChange={setDistro}
+              aria-label={tx("WSL distribution")}
+            />
+          </>
+        ) : (
+          <>
+            <label className={styles.label}>{tx("SSH configuration:")}</label>
+            <div className={styles.row}>
+              <Select
+                className={styles.grow}
+                value={ssh || null}
+                options={options}
+                placeholder={tx("No SSH configurations")}
+                onChange={(id) => {
+                  setSsh(id);
+                  setBrowse(null);
+                }}
+                aria-label={tx("SSH configuration")}
+              />
+              <Button onClick={() => void executeAction("file.settings", SSH_SETTINGS_PAGE)}>{tx("Configure…")}</Button>
+            </div>
+          </>
+        )}
         <label className={styles.label} htmlFor="remote-dev-path">
           {tx("Project directory:")}
         </label>
@@ -142,9 +195,12 @@ function ConnectDialog() {
             spellCheck={false}
             onChange={(e) => setPath(e.target.value)}
           />
-          <Button disabled={!ssh || busy} onClick={() => void list(path.trim() || "~")}>
-            {tx("Browse")}
-          </Button>
+          {/* Browsing lists over SFTP; a WSL distribution has no such session before connecting. */}
+          {!wsl && (
+            <Button disabled={!ssh || busy} onClick={() => void list(path.trim() || "~")}>
+              {tx("Browse")}
+            </Button>
+          )}
         </div>
         {browse && (
           <ul className={styles.folders} aria-label={tx("Remote folders")}>
diff --git a/src/features/remote-dev/RemoteStatus.tsx b/src/features/remote-dev/RemoteStatus.tsx
new file mode 100644
index 000000000..102306717
--- /dev/null
+++ b/src/features/remote-dev/RemoteStatus.tsx
@@ -0,0 +1,25 @@
+import { executeAction } from "@/platform/actions";
+import { tx } from "@/platform/i18n";
+import type { RemoteSession } from "@/platform/ipc";
+import { useRemote } from "@/platform/remote";
+import { BarButton } from "@/ui";
+
+/** Status bar label of a remote window: where its project runs. */
+export function remoteBadge(session: Pick<RemoteSession, "target" | "host">): string {
+  return `${session.target.kind === "wsl" ? "WSL" : "SSH"}: ${session.host}`;
+}
+
+export function RemoteStatus() {
+  const session = useRemote((s) => s.session);
+  if (!session) return null;
+  const label = remoteBadge(session);
+  return (
+    <BarButton
+      tooltip={tx`Project runs on ${label}`}
+      aria-label={label}
+      onClick={() => void executeAction("remote.connect")}
+    >
+      {label}
+    </BarButton>
+  );
+}
diff --git a/src/features/remote-dev/index.ts b/src/features/remote-dev/index.ts
index f690583ef..d5d6e0acd 100644
--- a/src/features/remote-dev/index.ts
+++ b/src/features/remote-dev/index.ts
@@ -1,19 +1,20 @@
 /**
- * Remote development: a window whose project lives on an SSH host. The backend
+ * Remote development: a window whose project lives on an SSH host or in a WSL distribution. The backend
  * (`openidea-server`) runs there and this window routes its commands to it
  * (platform/remote.ts).
  */
 import { registerActions } from "@/platform/actions";
 import { disconnectRemote, useRemote } from "@/platform/remote";
 import { lazyComponent } from "@/ui";
-import { maybeEditorService, registerOverlay, registerToolWindow } from "@/workbench/contributions";
+import { maybeEditorService, registerOverlay, registerStatusItem, registerToolWindow } from "@/workbench/contributions";
 import { confirmLeaveProject } from "@/platform/project";
 import { ConnectHost } from "./ConnectDialog";
 import { reloadEnvironment } from "./environment";
+import { RemoteStatus } from "./RemoteStatus";
 import { closeConnectDialog, openConnectDialog } from "./model";
 import { restorePorts, usePorts } from "./ports";
 
-/** The Ports tool window, while this window is connected to a remote host. */
+/** SSH tunnels are available while this window is connected to an SSH host. */
 function trackPortsWindow(): () => void {
   let off: (() => void) | null = null;
   const sync = (connected: boolean) => {
@@ -34,8 +35,8 @@ function trackPortsWindow(): () => void {
       usePorts.setState({ ports: [] });
     }
   };
-  sync(useRemote.getState().session !== null);
-  const unsubscribe = useRemote.subscribe((s) => sync(s.session !== null));
+  sync(useRemote.getState().session?.target.kind === "ssh");
+  const unsubscribe = useRemote.subscribe((s) => sync(s.session?.target.kind === "ssh"));
   return () => {
     unsubscribe();
     off?.();
@@ -46,6 +47,13 @@ export function activate(): () => void {
   const disposers = [
     trackPortsWindow(),
     registerOverlay({ id: "remote.connect", component: ConnectHost }),
+    registerStatusItem({
+      id: "remote.location",
+      title: "Remote Host",
+      align: "left",
+      priority: 100,
+      component: RemoteStatus,
+    }),
     registerActions([
       {
         id: "remote.connect",
diff --git a/src/features/remote-dev/ports.test.tsx b/src/features/remote-dev/ports.test.tsx
index 81037ec9f..ba07f6cc5 100644
--- a/src/features/remote-dev/ports.test.tsx
+++ b/src/features/remote-dev/ports.test.tsx
@@ -63,7 +63,9 @@ describe("restoring forwarded ports", () => {
   it("forwards the ports of this host and folder again after reconnecting", async () => {
     const { useRemote } = await import("@/platform/remote");
     const { forwardPort, restorePorts, savedPorts } = await import("./ports");
-    useRemote.setState({ session: { sshConfig: "lh", root: "/srv/app", host: "h", commands: [] } });
+    useRemote.setState({
+      session: { target: { kind: "ssh", config: "lh" }, root: "/srv/app", host: "h", os: "linux", commands: [] },
+    });
     await forwardPort(8080);
     expect(savedPorts()).toEqual([8080]);
     // Reconnected: the new connection forwards nothing yet.
@@ -73,7 +75,13 @@ describe("restoring forwarded ports", () => {
     expect(ipc.remoteForwardPort).toHaveBeenCalledWith(8080);
     expect(usePorts.getState().ports).toEqual([{ remotePort: 8080, localPort: 8080 }]);
     // Another folder on the same host has its own list.
-    useRemote.setState({ session: { sshConfig: "lh", root: "/srv/other", host: "h", commands: [] } });
+    useRemote.setState({
+      session: { target: { kind: "ssh", config: "lh" }, root: "/srv/other", host: "h", os: "linux", commands: [] },
+    });
+    expect(savedPorts()).toEqual([]);
+    useRemote.setState({
+      session: { target: { kind: "wsl", distro: "lh" }, root: "/srv/app", host: "lh", os: "linux", commands: [] },
+    });
     expect(savedPorts()).toEqual([]);
     useRemote.setState({ session: null });
   });
diff --git a/src/features/remote-dev/ports.ts b/src/features/remote-dev/ports.ts
index 856c2b9dc..8478260ef 100644
--- a/src/features/remote-dev/ports.ts
+++ b/src/features/remote-dev/ports.ts
@@ -10,7 +10,7 @@ const SAVED_KEY = "openidea.remote.ports:";
 
 function savedKey(): string | null {
   const session = useRemote.getState().session;
-  return session ? `${SAVED_KEY}${session.sshConfig}:${session.root}` : null;
+  return session?.target.kind === "ssh" ? `${SAVED_KEY}${session.target.config}:${session.root}` : null;
 }
 
 export function savedPorts(): number[] {
@@ -53,6 +53,14 @@ export function parsePort(text: string): number | null {
 }
 
 export async function forwardPort(port: number): Promise<ForwardedPort | null> {
+  if (useRemote.getState().session?.target.kind === "wsl") {
+    notifications().notify({
+      group: "remote",
+      level: "error",
+      title: tx("Forwarding ports is not supported in a WSL project yet"),
+    });
+    return null;
+  }
   try {
     const forwarded = await call(commands.remoteForwardPort(port));
     await refreshPorts(true);
diff --git a/src/features/remote-dev/remoteDev.test.ts b/src/features/remote-dev/remoteDev.test.ts
index 68f94a935..97ffa2cf9 100644
--- a/src/features/remote-dev/remoteDev.test.ts
+++ b/src/features/remote-dev/remoteDev.test.ts
@@ -10,6 +10,7 @@ import {
   remoteLocation,
 } from "@/platform/remote";
 import { browsableFolders, listedDirectory, remoteParent } from "./model";
+import { remoteBadge } from "./RemoteStatus";
 
 const entry = (path: string, isDir = true): RemoteEntry => ({
   name: path.slice(path.lastIndexOf("/") + 1),
@@ -47,33 +48,79 @@ describe("remote folder browser", () => {
   });
 });
 
+const ssh = (config: string) => ({ kind: "ssh", config }) as const;
+const wsl = (distro: string) => ({ kind: "wsl", distro }) as const;
+
 describe("remote project locations", () => {
   it("round-trip the configuration id and the path", () => {
-    const loc = remoteLocation("mac mini/1", "/Users/me/repo");
+    const loc = remoteLocation(ssh("mac mini/1"), "/Users/me/repo");
     expect(loc).toBe("ssh://mac%20mini%2F1/Users/me/repo");
-    expect(parseRemoteLocation(loc)).toEqual({ sshConfig: "mac mini/1", path: "/Users/me/repo" });
+    expect(parseRemoteLocation(loc)).toEqual({ target: ssh("mac mini/1"), path: "/Users/me/repo" });
     expect(parseRemoteLocation("/Users/me/repo")).toBeNull();
   });
 
+  it("round-trip a WSL distribution and the path", () => {
+    const loc = remoteLocation(wsl("Ubuntu-24.04"), "/home/me/app");
+    expect(loc).toBe("wsl://Ubuntu-24.04/home/me/app");
+    expect(parseRemoteLocation(loc)).toEqual({ target: wsl("Ubuntu-24.04"), path: "/home/me/app" });
+    expect(parseRemoteLocation("wsl://Ubuntu")).toBeNull();
+  });
+
   it("remembers recent remote projects most recent first, once each", () => {
     localStorage.clear();
-    rememberRemote({ sshConfig: "a", path: "/p", name: "p", host: "me@a", openedAtMs: 1 });
-    rememberRemote({ sshConfig: "b", path: "/q", name: "q", host: "me@b", openedAtMs: 2 });
-    rememberRemote({ sshConfig: "a", path: "/p", name: "p", host: "me@a", openedAtMs: 3 });
+    rememberRemote({ target: ssh("a"), path: "/p", name: "p", host: "me@a", openedAtMs: 1 });
+    rememberRemote({ target: ssh("b"), path: "/q", name: "q", host: "me@b", openedAtMs: 2 });
+    rememberRemote({ target: ssh("a"), path: "/p", name: "p", host: "me@a", openedAtMs: 3 });
     expect(recentRemotes().map((r) => r.path)).toEqual(["/p", "/q"]);
-    forgetRemote("a", "/p");
+    forgetRemote(ssh("a"), "/p");
     expect(recentRemotes().map((r) => r.path)).toEqual(["/q"]);
   });
+
+  it("keeps an SSH host and a WSL distribution of the same name apart", () => {
+    localStorage.clear();
+    rememberRemote({ target: ssh("dev"), path: "/p", name: "p", host: "me@dev", openedAtMs: 1 });
+    rememberRemote({ target: wsl("dev"), path: "/p", name: "p", host: "dev", openedAtMs: 2 });
+    expect(recentRemotes()).toHaveLength(2);
+    forgetRemote(wsl("dev"), "/p");
+    expect(recentRemotes().map((r) => r.target)).toEqual([ssh("dev")]);
+  });
+
+  it("reads recents saved before WSL support, which carried `sshConfig`", () => {
+    localStorage.clear();
+    localStorage.setItem(
+      "openidea.remote.recent",
+      JSON.stringify([
+        { sshConfig: "old", path: "/p", name: "p", host: "me@old", openedAtMs: 1 },
+        { path: "/no-target" },
+      ]),
+    );
+    expect(recentRemotes().map((r) => r.target)).toEqual([ssh("old")]);
+  });
 });
 
 it("migrates only the original remote recents once, scoped to the saved host", () => {
   localStorage.clear();
-  rememberRemote({ sshConfig: "a", path: "/old", host: "me@old", name: "old", openedAtMs: 1 });
+  rememberRemote({ target: ssh("a"), path: "/old", host: "me@old", name: "old", openedAtMs: 1 });
   initializeRemoteTrustMigration();
-  rememberRemote({ sshConfig: "a", path: "/new", host: "me@old", name: "new", openedAtMs: 2 });
+  rememberRemote({ target: ssh("a"), path: "/new", host: "me@old", name: "new", openedAtMs: 2 });
   initializeRemoteTrustMigration();
-  expect(takeLegacyRemoteTrust("a", "/new", "me@old")).toBe(false);
-  expect(takeLegacyRemoteTrust("a", "/old", "me@other")).toBe(false);
-  expect(takeLegacyRemoteTrust("a", "/old", "me@old")).toBe(true);
-  expect(takeLegacyRemoteTrust("a", "/old", "me@old")).toBe(false);
+  expect(takeLegacyRemoteTrust(ssh("a"), "/new", "me@old")).toBe(false);
+  expect(takeLegacyRemoteTrust(ssh("a"), "/old", "me@other")).toBe(false);
+  expect(takeLegacyRemoteTrust(ssh("a"), "/old", "me@old")).toBe(true);
+  expect(takeLegacyRemoteTrust(ssh("a"), "/old", "me@old")).toBe(false);
+});
+
+it("migrates a snapshot taken before WSL support, and never trusts a WSL distribution", () => {
+  localStorage.clear();
+  localStorage.setItem(
+    "openidea.remote.trustMigration",
+    JSON.stringify([{ sshConfig: "a", path: "/old", host: "me@old", name: "old", openedAtMs: 1 }]),
+  );
+  expect(takeLegacyRemoteTrust(wsl("a"), "/old", "me@old")).toBe(false);
+  expect(takeLegacyRemoteTrust(ssh("a"), "/old", "me@old")).toBe(true);
+});
+
+it("labels the status bar with the transport and where the project runs", () => {
+  expect(remoteBadge({ target: wsl("Ubuntu"), host: "Ubuntu" })).toBe("WSL: Ubuntu");
+  expect(remoteBadge({ target: ssh("a"), host: "me@a:22" })).toBe("SSH: me@a:22");
 });
diff --git a/src/features/run/application.ts b/src/features/run/application.ts
index b77cc1f00..8c9ae40c5 100644
--- a/src/features/run/application.ts
+++ b/src/features/run/application.ts
@@ -34,7 +34,7 @@ export function applicationConfig(
     kind: target.spring ? "spring-boot" : "application",
     command: "java",
     args: ["-cp", isTestSource(relPath) ? TEST_CLASSPATH : CLASSPATH, target.className],
-    cwd: module || null,
+    cwd: null,
     module,
     env: {},
     detected: true,
diff --git a/src/features/run/contextRun.ts b/src/features/run/contextRun.ts
index c67144c11..8e7f1bed9 100644
--- a/src/features/run/contextRun.ts
+++ b/src/features/run/contextRun.ts
@@ -50,7 +50,8 @@ async function ensureConfigs() {
 export function projectContentRoots(): string[] {
   const own = validateProjectStructure(useProject.getState().settings?.projectStructure).contentRoots;
   // The build model keeps the folders of modules outside the project absolute.
-  const gradle = (useBuildModel.getState().model?.gradle?.projects ?? [])
+  const gradle = (useBuildModel.getState().model?.gradle ?? [])
+    .flatMap((g) => g.projects)
     .map((p) => p.dir)
     .filter((d) => isAbsolute(d));
   return [...new Set([...own, ...gradle])];
diff --git a/src/features/run/dialogs.tsx b/src/features/run/dialogs.tsx
index 3c7e53e9a..67f1a3660 100644
--- a/src/features/run/dialogs.tsx
+++ b/src/features/run/dialogs.tsx
@@ -52,24 +52,7 @@ export async function confirmRerun(name: string, instances = 1): Promise<boolean
   return answer !== null;
 }
 
-/** IDEA's question before closing a Run tab whose process still runs. Resolves true for Terminate. */
-export async function confirmTerminate(name: string): Promise<boolean> {
-  const answer = await confirmChecked({
-    title: tx`Process '${name}' Is Running`,
-    message: tx`Do you want to terminate the process '${name}'?`,
-    ok: "Terminate",
-    checkbox: "Do not ask again",
-  });
-  if (answer?.checked && isTauri()) {
-    try {
-      await call(commands.settingsSet("global", "run.confirmTerminate", "false"));
-      await loadSettings();
-    } catch {
-      /* keep asking */
-    }
-  }
-  return answer !== null;
-}
+export { confirmTerminate } from "@/workbench/confirmTerminate";
 
 /** Asks for the value of `$Prompt$`; null when cancelled. */
 export function promptValue(title: string): Promise<string | null> {
diff --git a/src/features/run/gradleRun.test.ts b/src/features/run/gradleRun.test.ts
index 642091c3e..e96112c0c 100644
--- a/src/features/run/gradleRun.test.ts
+++ b/src/features/run/gradleRun.test.ts
@@ -1,9 +1,31 @@
-import { describe, expect, it } from "vitest";
-import type { GradleModel, RunConfig } from "@/platform/ipc";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { GradleModel, ProjectInfo, RunConfig } from "@/platform/ipc";
 import { applicationConfig } from "./application";
-import { DELEGATED_DEBUG, delegatedGradleConfig, withTestEvents, wrapperGradleVersion } from "./gradleRun";
+import {
+  DELEGATED_DEBUG,
+  delegatedGradleConfig,
+  gradleDelegation,
+  withTestEvents,
+  wrapperGradleVersion,
+} from "./gradleRun";
 import { jdwpLaunch } from "./javaDebug";
 import { isJvmApplication } from "@/platform/javaLaunch";
+import { useBuildModel } from "@/platform/buildModel";
+import { useProject } from "@/platform/project";
+
+vi.mock("@/platform/ipc", async (original) => {
+  const real = await original<typeof import("@/platform/ipc")>();
+  return {
+    ...real,
+    isTauri: () => true,
+    call: (value: unknown) => value,
+    commands: {
+      ...real.commands,
+      runGradleInitScript: () => Promise.resolve("/tmp/openidea-gradle-run.gradle"),
+      fsReadText: () => Promise.resolve("distributionUrl=https://x/gradle-8.10-bin.zip"),
+    },
+  };
+});
 
 const ROOT = "/w/shop";
 const CORE = "/w/billing/modules/core";
@@ -143,3 +165,54 @@ describe("Gradle test runs", () => {
     expect(withTestEvents(twice, script)).toBe(twice);
   });
 });
+
+describe("delegation across independent builds", () => {
+  afterEach(() => {
+    useProject.setState({ project: null, settings: null });
+    useBuildModel.setState({ root: null, model: null, gradleOffline: false });
+  });
+
+  it("selects the module's linked build and preserves composite identity task paths", async () => {
+    const builds = ["first", "second"].map((dir) => ({
+      ...gradle,
+      dir,
+      command: `${ROOT}/${dir}/gradlew`,
+      env: { JAVA_HOME: `/${dir}/jdk` },
+      projects: [{ path: ":app", name: "app", dir: `${dir}/app`, buildFile: null, tasks: [] }],
+    }));
+    useProject.setState({ project: { root: ROOT } as ProjectInfo, settings: null });
+    useBuildModel.setState({ root: ROOT, model: { maven: null, gradle: builds }, gradleOffline: true });
+    const app = {
+      ...applicationConfig({ className: "a.Main" }, "second/app/src/main/java/a/Main.java", []),
+      module: "second/app",
+    };
+    const run = await gradleDelegation(app);
+    expect(run).toMatchObject({ command: `${ROOT}/second/gradlew`, cwd: "second", env: { JAVA_HOME: "/second/jdk" } });
+    expect(run!.args).toContain("--offline");
+    expect(run!.args.at(-1)).toBe(":app:openideaRun");
+  });
+
+  it("prefers the directly linked owner over a longer sibling composite root", async () => {
+    const composite = {
+      ...gradle,
+      dir: "very-long-composite",
+      command: `${ROOT}/very-long-composite/gradlew`,
+      projects: [{ path: ":b:app", name: "app", dir: "b/app", buildFile: null, tasks: [], build: ":b" }],
+    };
+    const direct = {
+      ...gradle,
+      dir: "b",
+      command: `${ROOT}/b/gradlew`,
+      projects: [{ path: ":app", name: "app", dir: "b/app", buildFile: null, tasks: [] }],
+    };
+    useProject.setState({ project: { root: ROOT } as ProjectInfo, settings: null });
+    useBuildModel.setState({ root: ROOT, model: { maven: null, gradle: [composite, direct] } });
+    const app = {
+      ...applicationConfig({ className: "a.Main" }, "b/app/src/main/java/a/Main.java", []),
+      module: "b/app",
+    };
+    const run = await gradleDelegation(app);
+    expect(run).toMatchObject({ command: `${ROOT}/b/gradlew`, cwd: "b" });
+    expect(run!.args.at(-1)).toBe(":app:openideaRun");
+  });
+});
diff --git a/src/features/run/gradleRun.ts b/src/features/run/gradleRun.ts
index f17082838..e643aefb7 100644
--- a/src/features/run/gradleRun.ts
+++ b/src/features/run/gradleRun.ts
@@ -135,12 +135,23 @@ export async function gradleDelegation(config: RunConfig): Promise<RunConfig | n
   const { project, settings } = useProject.getState();
   if (!project?.root || settings?.languages?.java?.gradle?.runUsing === "ide") return null;
   const { model, gradleOffline } = useBuildModel.getState();
-  if (!model?.gradle) return null;
+  if (!model?.gradle?.length) return null;
   const module = config.module ?? (await findJavaModule(config));
   if (module === null) return null;
+  const dir = absolute(project.root, module);
+  // A composite can report a sibling's module; prefer a linked root that contains it.
+  const ownerDepth = (g: GradleModel) => {
+    const root = absolute(project.root, g.dir).replace(/\\/g, "/").replace(/\/+$/, "");
+    const path = dir.replace(/\\/g, "/").replace(/\/+$/, "");
+    return path === root || path.startsWith(`${root}/`) ? root.split("/").length : 0;
+  };
+  const gradle = model.gradle
+    .filter((g) => g.projects.some((p) => absolute(project.root, p.dir) === dir))
+    .sort((a, b) => ownerDepth(b) - ownerDepth(a))[0];
+  if (!gradle) return null;
   const ctx = {
     root: project.root,
-    gradle: model.gradle,
+    gradle,
     script: "",
     offline: gradleOffline,
     configurationCache: false,
diff --git a/src/features/run/index.ts b/src/features/run/index.ts
index a663c368c..10ffa6113 100644
--- a/src/features/run/index.ts
+++ b/src/features/run/index.ts
@@ -16,6 +16,7 @@ import {
   registerMenuGroup,
   registerOverlay,
   registerRunAnythingProvider,
+  registerRunningProcessesProvider,
   registerServiceProvider,
   registerTitleItem,
   registerToolWindow,
@@ -42,6 +43,7 @@ import { invalidatePythonPackages } from "./pythonPackages";
 import { RunWidget } from "./RunWidget";
 import { runConfigsRunAnything } from "./runAnything";
 import { cleanupRemovedProject, recordRun, runServiceProvider } from "./services";
+import { liveServiceSession, serviceSessions } from "./serviceSessions";
 import { runBeforeLaunch } from "./beforeLaunch";
 import { compoundChildren } from "./configs";
 import { remoteDebugBlocked } from "./remote";
@@ -294,6 +296,13 @@ export function activate(): () => void {
     registerOverlay({ id: "run.editConfigs", component: EditConfigsOverlay }),
     registerOverlay({ id: "run.dialogs", component: RunDialogsOverlay }),
     registerServiceProvider(runServiceProvider),
+    registerRunningProcessesProvider({
+      id: "run",
+      running: () =>
+        serviceSessions(useRun.getState().sessions, useDebugRunSessions.getState().serviceSessions)
+          .filter(liveServiceSession)
+          .map((s) => ({ name: s.config.name })),
+    }),
     onWorkflowSettingsChange((w) => w.console, applyConsoleSettings),
     registerExternalTools(),
     activateStackTrace(),
diff --git a/src/features/run/java.test.ts b/src/features/run/java.test.ts
index f74d3e7ec..5c74648ba 100644
--- a/src/features/run/java.test.ts
+++ b/src/features/run/java.test.ts
@@ -224,7 +224,8 @@ describe("application configurations", () => {
     });
     expect(applicationConfig({ className: "a.Tool" }, "m/src/test/java/a/Tool.java")).toMatchObject({
       kind: "application",
-      cwd: "m",
+      module: "m",
+      cwd: null,
       args: ["-cp", "${testClasspath}", "a.Tool"],
     });
   });
diff --git a/src/features/run/jvmTypes.test.ts b/src/features/run/jvmTypes.test.ts
index 921f0afc5..a4aa91760 100644
--- a/src/features/run/jvmTypes.test.ts
+++ b/src/features/run/jvmTypes.test.ts
@@ -16,6 +16,7 @@ vi.mock("@/platform/ipc", async (orig) => {
   };
 });
 
+const { usePlatform } = await import("@/platform/platformInfo");
 const { parseJavaArgs, joinJavaArgs } = await import("@/platform/javaLaunch");
 const { parseArgs } = await import("./configs");
 const { jdwpLaunch } = await import("./javaDebug");
@@ -247,3 +248,34 @@ describe("Maven / Gradle: VM options of the forked JVM", () => {
     await expect(gradle().prepareLaunch!(remote)).rejects.toThrow(/run targets/);
   });
 });
+
+describe("build wrapper per execution host", () => {
+  const wrapperCommands = () =>
+    (["gradle", "maven"] as const).map((t) => typeFor(t)!.commandLine({ wrapper: "true", tasks: "test" })!.command);
+  const WINDOWS = ["gradlew.bat", "mvnw.cmd"];
+  const UNIX = ["./gradlew", "./mvnw"];
+
+  beforeEach(() => registerBuiltinTypes());
+  afterEach(async () => {
+    (await import("@/platform/remote")).disableRemote();
+    usePlatform.setState({ os: "macos" });
+  });
+
+  it("follows the desktop OS in a local window", () => {
+    usePlatform.setState({ os: "windows" });
+    expect(wrapperCommands()).toEqual(WINDOWS);
+    usePlatform.setState({ os: "linux" });
+    expect(wrapperCommands()).toEqual(UNIX);
+  });
+
+  it.each([
+    { desktop: "windows", host: "linux", target: { kind: "wsl", distro: "Ubuntu" }, expected: UNIX },
+    { desktop: "windows", host: "macos", target: { kind: "ssh", config: "box" }, expected: UNIX },
+    { desktop: "macos", host: "windows", target: { kind: "ssh", config: "win" }, expected: WINDOWS },
+  ] as const)("follows the $host server of a remote window opened from $desktop", async (c) => {
+    usePlatform.setState({ os: c.desktop });
+    const { enableRemote } = await import("@/platform/remote");
+    enableRemote({ target: c.target, root: "/app", host: "h", os: c.host, commands: [] });
+    expect(wrapperCommands()).toEqual(c.expected);
+  });
+});
diff --git a/src/features/run/jvmTypes.ts b/src/features/run/jvmTypes.ts
index 6b1d6f0e6..971923b7a 100644
--- a/src/features/run/jvmTypes.ts
+++ b/src/features/run/jvmTypes.ts
@@ -6,6 +6,7 @@
  */
 import { call, commands, type RunConfig } from "@/platform/ipc";
 import { CLASSPATH, parseJavaArgs, TEST_CLASSPATH } from "@/platform/javaLaunch";
+import { hostOs } from "@/platform/remote";
 import { basename, useProject } from "@/platform/project";
 import { useBuildPresentation } from "@/platform/projectPresentation";
 import type { RunConfigTypeContribution, RunConfigTypeField } from "@/workbench/contributions";
@@ -13,7 +14,8 @@ import { formatArgs, parseArgs } from "./configs";
 import { commandName } from "./commandName";
 import { updatePolicyDefaults, updatePolicyFields } from "./updatePolicies";
 
-export const isWindows = () => typeof navigator !== "undefined" && /win/i.test(navigator.platform);
+/** Whether this window's commands run on Windows: the remote server's OS in a remote window, else the desktop's. */
+export const isWindows = () => hostOs() === "windows";
 
 /** VM options / program arguments as typed; on Windows a backslash is a path separator. */
 export const splitJvmArgs = (text: string | undefined, windows = isWindows()) => parseArgs(text ?? "", windows);
diff --git a/src/features/run/producers.test.ts b/src/features/run/producers.test.ts
index 21574434e..4c3812cf1 100644
--- a/src/features/run/producers.test.ts
+++ b/src/features/run/producers.test.ts
@@ -425,7 +425,7 @@ describe("single-file producers (scratches)", () => {
     });
     expect(produceContext(input(), ALL)!.config!.kind).toBe("java-file");
     const p = produceContext(input(["/work/billing", svc]), ALL)!;
-    expect(p.config).toMatchObject({ kind: "spring-boot", module: svc, cwd: svc });
+    expect(p.config).toMatchObject({ kind: "spring-boot", module: svc, cwd: null });
     expect(p.config!.args).toEqual(["-cp", "${classpath}", "com.example.ShopApplication"]);
   });
 
@@ -487,7 +487,8 @@ describe("single-file producers (scratches)", () => {
             kind: "spring-boot",
             name: "DromaraApplication",
             command: "java",
-            cwd: module,
+            module,
+            cwd: null,
           });
           expect(p!.config!.args).toEqual(["-cp", "${classpath}", "org.dromara.DromaraApplication"]);
         }
@@ -503,7 +504,7 @@ describe("single-file producers (scratches)", () => {
     it("Kotlin and test classes use the build that contains them", () => {
       const kt = "package demo\n\nfun main() {\n  println(1)\n}\n";
       const p = produceContext(at("backend/app/src/main/kotlin/demo/App.kt", nested("gradle", "backend"), kt, 3), ALL)!;
-      expect(p.config).toMatchObject({ kind: "application", cwd: "backend/app" });
+      expect(p.config).toMatchObject({ kind: "application", module: "backend/app", cwd: null });
       expect(p.config!.args.at(-1)).toBe("demo.AppKt");
       const test = "package demo;\nclass AppTest {\n  @Test\n  void works() {\n  }\n}\n";
       const t = produceContext(
diff --git a/src/features/run/producers.ts b/src/features/run/producers.ts
index 85f6d0b5c..cfca6c5bb 100644
--- a/src/features/run/producers.ts
+++ b/src/features/run/producers.ts
@@ -807,7 +807,7 @@ export function produceFile(input: ContextInput, env: ToolEnv): Produced | null
     case "r":
       return simple(lang, s, env, "r", () => [s.arg]);
     case "dart":
-      return simple(lang, s, env, "dart", () => ["run", s.arg]);
+      return simple(lang, s, env, "dart", () => ["run", s.arg], "dart");
     case "scala":
       return simple(lang, s, env, "scala-cli", () => ["run", s.arg]);
     case "kotlin":
diff --git a/src/features/run/runtimes.ts b/src/features/run/runtimes.ts
index b8bb4b3a5..b6d21d7bb 100644
--- a/src/features/run/runtimes.ts
+++ b/src/features/run/runtimes.ts
@@ -5,6 +5,7 @@
  * Rust come from SDK discovery and everything else resolves at launch.
  */
 import { call, commands, isTauri } from "@/platform/ipc";
+import { isWindows } from "./jvmTypes";
 import type { LocatedTool, ToolEnv } from "./producers";
 
 const TTL = 60_000;
@@ -15,7 +16,6 @@ interface Entry {
 }
 
 const cache = new Map<string, Entry>();
-const isWindows = typeof navigator !== "undefined" && /Win/i.test(navigator.platform || navigator.userAgent);
 let compileDir: string | null = null;
 let locateUnavailable = false;
 
@@ -115,7 +115,7 @@ export async function toolEnv(
   return {
     tool: (n) => tools.get(n),
     compileDir: compileDir ?? "/tmp/openidea-run",
-    windows: isWindows,
+    windows: isWindows(),
     python: py,
     ...markers,
   };
diff --git a/src/features/services/ServicesTree.reorder.test.tsx b/src/features/services/ServicesTree.reorder.test.tsx
index 011400816..611cd9dc1 100644
--- a/src/features/services/ServicesTree.reorder.test.tsx
+++ b/src/features/services/ServicesTree.reorder.test.tsx
@@ -138,7 +138,17 @@ describe("service reordering integration", () => {
     render(<ServicesTreeView />);
     select("Portal");
     fireEvent.click(screen.getByRole("button", { name: "Move Up" }));
-    act(() => useRemote.setState({ session: { root: "/services", sshConfig: "host", host: "host", commands: [] } }));
+    act(() =>
+      useRemote.setState({
+        session: {
+          root: "/services",
+          target: { kind: "ssh", config: "host" },
+          host: "host",
+          os: "linux",
+          commands: [],
+        },
+      }),
+    );
     expect(names()).toEqual(["Spring Boot", "Gateway", "Portal", "npm", "Web", "Worker", "Docker"]);
     act(() => useRemote.setState({ session: null }));
     expect(names()).toEqual(["Spring Boot", "Portal", "Gateway", "npm", "Web", "Worker", "Docker"]);
diff --git a/src/features/services/runTypes.ts b/src/features/services/runTypes.ts
index f54acbd06..d82cc80d8 100644
--- a/src/features/services/runTypes.ts
+++ b/src/features/services/runTypes.ts
@@ -9,6 +9,7 @@
 import { splitCommandLine } from "@/platform/commandLine";
 import { call, commands, type RunConfig } from "@/platform/ipc";
 import { registerRunConfigType, type RunConfigTypeContribution } from "@/workbench/contributions";
+import { hostOs } from "@/platform/remote";
 import { imageTag, targetTitle, type DockerTarget } from "./compose";
 import { connections, endpointOf, loadSettings, useServices } from "./store";
 import { tx } from "@/platform/i18n";
@@ -19,7 +20,7 @@ export const DOCKER_COMPOSE = "docker-compose";
 
 const GROUP = "Docker";
 const on = (v: string | undefined) => v === "true";
-const isWindows = () => typeof navigator !== "undefined" && /win/i.test(navigator.platform);
+const isWindows = () => hostOs() === "windows";
 
 /** One word for the platform shell the run executes the line with (`/bin/sh -c` or `cmd /C`). */
 export function shellQuote(word: string, windows = isWindows()): string {
diff --git a/src/features/settings/__tests__/languages.test.ts b/src/features/settings/__tests__/languages.test.ts
index c4b266812..46d86a3f7 100644
--- a/src/features/settings/__tests__/languages.test.ts
+++ b/src/features/settings/__tests__/languages.test.ts
@@ -42,6 +42,7 @@ describe("languages settings", () => {
       userSettings: "",
       localRepository: "",
       unlinkedProjects: [],
+      linkedProjects: [],
       daemon: false,
       mvndHome: "/opt/mvnd",
     });
diff --git a/src/features/settings/components/Form.tsx b/src/features/settings/components/Form.tsx
index 5bc75c2f7..ad6fbc358 100644
--- a/src/features/settings/components/Form.tsx
+++ b/src/features/settings/components/Form.tsx
@@ -171,16 +171,18 @@ export interface SelectProps<V extends string> {
   options: readonly SelectOption<V>[];
   onChange: (value: V) => void;
   disabled?: boolean;
+  onPreview?: (value: V | null) => void;
   "aria-label"?: string;
 }
 
-export function Select<V extends string>({ value, options, onChange, disabled, ...aria }: SelectProps<V>) {
+export function Select<V extends string>({ value, options, onChange, disabled, onPreview, ...aria }: SelectProps<V>) {
   return (
     <UiSelect<V>
       value={value}
       options={options}
       onChange={onChange}
       disabled={disabled}
+      onPreview={onPreview}
       className={styles.select}
       aria-label={aria["aria-label"]}
     />
diff --git a/src/features/settings/pages/behavior.tsx b/src/features/settings/pages/behavior.tsx
index b5a6bbd46..e77441ed3 100644
--- a/src/features/settings/pages/behavior.tsx
+++ b/src/features/settings/pages/behavior.tsx
@@ -6,7 +6,7 @@
  */
 
 import { FontPicker } from "../components/FontPicker";
-import { useId, useRef, useState, type ReactNode } from "react";
+import { useEffect, useId, useMemo, useRef, useState, type ReactNode } from "react";
 import clsx from "clsx";
 import { shortcutLabel } from "@/platform/keymap";
 import { usePlatform } from "@/platform/platformInfo";
@@ -33,7 +33,8 @@ import { HTTP_PROXY_PAGE } from "./httpProxy";
 import styles from "./Behavior.module.css";
 import { LOCALES, SUPPORTED_LOCALES, tx, useT } from "@/platform/i18n";
 import { BUILTIN_THEMES, useContributedIconThemes } from "@/platform/themes";
-import { originDetail, themeSelectOptions, useThemeChoices } from "@/workbench/theme";
+import { currentThemeChoice, originDetail, previewTheme, themeSelectOptions, useThemeChoices } from "@/workbench/theme";
+import { themePreview } from "@/workbench/quickSwitch";
 
 const BUILTIN_THEME_LABELS = BUILTIN_THEMES.map((t) => t.label);
 
@@ -62,12 +63,28 @@ function ThemeRow() {
   const matched = useLabelMatch("Sync with OS");
   const choices = useThemeChoices();
   const shown: ConcreteTheme = theme === "system" ? "light" : theme;
+  // The theme under the pointer shows as in Quick Switch; the one picked here shows until Apply or Cancel.
+  const picker = useMemo(() => themePreview(), []);
+  const previewed = useRef(false);
+  useEffect(
+    () => () => {
+      if (previewed.current) previewTheme(null);
+    },
+    [],
+  );
+  const preview = (id: ConcreteTheme | null) => {
+    previewed.current = true;
+    if (id !== null) return picker.preview(id);
+    picker.restore();
+    if (shown !== currentThemeChoice()) previewTheme(shown);
+  };
   return (
     <Row label="Theme">
       <Select<ConcreteTheme>
         value={shown}
         options={themeSelectOptions(choices, shown)}
         onChange={setTheme}
+        onPreview={preview}
         aria-label="Theme"
         disabled={sync}
       />
diff --git a/src/features/settings/pages/editor/colorScheme.tsx b/src/features/settings/pages/editor/colorScheme.tsx
index 16024a1e8..6831c494a 100644
--- a/src/features/settings/pages/editor/colorScheme.tsx
+++ b/src/features/settings/pages/editor/colorScheme.tsx
@@ -55,11 +55,15 @@ function buildTree(): Node[] {
 
 const TREE = buildTree();
 
-/** CSS custom properties of a scheme plus pending overrides (for the preview). */
+/**
+ * CSS custom properties of a scheme plus pending overrides (for the preview); with
+ * `language`, that language's own colours on top, as its editors show them.
+ */
 function previewVars(
   id: string,
   o: Record<string, TextAttributesOverride> | undefined,
   customs: CustomColorSchemes,
+  language?: string,
 ): CSSProperties {
   const vars: Record<string, string> = {};
   const tokens = resolvedSchemeTokens(id, customs);
@@ -74,6 +78,10 @@ function previewVars(
       vars[k] = v;
   vars["--bg-editor"] = tokens.get("--bg-editor") ?? tokens.get("--bg-island") ?? "";
   for (const [key, value] of overrideDeclarations(o)) vars[key] = value;
+  if (language) {
+    for (const [key, value] of overrideDeclarations(customs[id]?.attributes, language)) vars[key] = value;
+    for (const [key, value] of overrideDeclarations(o, language)) vars[key] = value;
+  }
   return vars as CSSProperties;
 }
 
@@ -276,9 +284,10 @@ function ColorSchemePage() {
   const id = effectiveScheme(scheme, undefined, customs);
   const mine = overrides?.[id];
   const attr = ATTRIBUTES.find((a) => a.id === selected);
+  const language = attr?.language;
   const vars = useMemo(
-    () => ({ ...previewVars(id, mine, customs), ...fontWeightVars(weight, boldFontWeight) }) as CSSProperties,
-    [id, mine, customs, weight, boldFontWeight],
+    () => ({ ...previewVars(id, mine, customs, language), ...fontWeightVars(weight, boldFontWeight) }) as CSSProperties,
+    [id, mine, customs, language, weight, boldFontWeight],
   );
   const update = (attrId: string, v: TextAttributesOverride | undefined) => {
     const next: Overrides = { ...(overrides ?? {}) };
diff --git a/src/features/terminal/imeInput.test.ts b/src/features/terminal/imeInput.test.ts
new file mode 100644
index 000000000..8fb77fed4
--- /dev/null
+++ b/src/features/terminal/imeInput.test.ts
@@ -0,0 +1,159 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { ownTerminalInput } from "./imeInput";
+
+/** What xterm does with the textarea, in miniature: a listener that must stay out of our commits. */
+function setup() {
+  const host = document.createElement("div");
+  const textarea = document.createElement("textarea");
+  host.append(textarea);
+  document.body.append(host);
+  const sent: string[] = [];
+  const reached: string[] = [];
+  textarea.addEventListener("input", (e) => reached.push((e as InputEvent).inputType));
+  textarea.addEventListener("keydown", () => reached.push("keydown"));
+  textarea.addEventListener("keypress", () => reached.push("keypress"));
+  textarea.addEventListener("compositionstart", () => reached.push("compositionstart"));
+  textarea.addEventListener("compositionend", () => reached.push("compositionend"));
+  const dispose = ownTerminalInput({ host, textarea, send: (d) => sent.push(d) });
+  return { host, textarea, sent, reached, dispose };
+}
+
+function keydown(target: EventTarget, init: { key: string; keyCode: number; isComposing?: boolean; altKey?: boolean }) {
+  const e = new KeyboardEvent("keydown", { key: init.key, altKey: init.altKey, bubbles: true, cancelable: true });
+  Object.defineProperty(e, "keyCode", { value: init.keyCode });
+  if (init.isComposing) Object.defineProperty(e, "isComposing", { value: true });
+  target.dispatchEvent(e);
+  return e;
+}
+
+function keypress(target: EventTarget, key: string) {
+  const e = new KeyboardEvent("keypress", { key, bubbles: true, cancelable: true });
+  target.dispatchEvent(e);
+  return e;
+}
+
+function keyup(target: EventTarget, keyCode: number) {
+  const e = new KeyboardEvent("keyup", { key: "", bubbles: true });
+  Object.defineProperty(e, "keyCode", { value: keyCode });
+  target.dispatchEvent(e);
+  return e;
+}
+
+function input(target: EventTarget, init: { inputType: string; data?: string; isComposing?: boolean }) {
+  const e = new Event("input", { bubbles: true, cancelable: true });
+  Object.defineProperties(e, {
+    inputType: { value: init.inputType },
+    data: { value: init.data ?? null },
+    composed: { value: true },
+    isComposing: { value: init.isComposing ?? false },
+  });
+  target.dispatchEvent(e);
+  return e;
+}
+
+describe("ownTerminalInput", () => {
+  beforeEach(() => {
+    document.body.replaceChildren();
+  });
+
+  it("sends a commit that xterm's input-event gate would drop", () => {
+    // Doubao on macOS: a 229 keydown, then insertText while the keydown is still pending —
+    // CoreBrowserTerminal._inputEvent ignores exactly that and the character disappears.
+    const { textarea, sent, reached } = setup();
+    keydown(textarea, { key: "1", keyCode: 229, isComposing: true });
+    input(textarea, { inputType: "insertText", data: "1", isComposing: true });
+    expect(sent).toEqual(["1"]);
+    expect(reached).toEqual([]);
+  });
+
+  it("leaves a commit the keyup already unblocked to xterm", () => {
+    // Late injection with no keydown pending: xterm's own _inputEvent accepts it.
+    const { textarea, sent, reached } = setup();
+    keydown(textarea, { key: "1", keyCode: 229 });
+    keyup(textarea, 229);
+    input(textarea, { inputType: "insertText", data: "1" });
+    expect(sent).toEqual([]);
+    expect(reached).toEqual(["insertText"]);
+  });
+
+  it("sends every key of a fast run exactly once", () => {
+    const { textarea, sent } = setup();
+    for (const key of "1234567890") {
+      keydown(textarea, { key, keyCode: 229 });
+      input(textarea, { inputType: "insertText", data: key });
+      keyup(textarea, 229);
+    }
+    expect(sent.join("")).toBe("1234567890");
+  });
+
+  it("sends a multi-character commit once", () => {
+    const { textarea, sent } = setup();
+    keydown(textarea, { key: "1", keyCode: 229 });
+    input(textarea, { inputType: "insertText", data: "123" });
+    expect(sent).toEqual(["123"]);
+  });
+
+  it("sends a composition commit reported without compositionstart", () => {
+    const { textarea, sent } = setup();
+    input(textarea, { inputType: "insertFromComposition", data: "，" });
+    expect(sent).toEqual(["，"]);
+  });
+
+  it("leaves keys xterm's keydown path already sent to xterm", () => {
+    const { textarea, sent, reached } = setup();
+    keydown(textarea, { key: "a", keyCode: 65 });
+    input(textarea, { inputType: "insertText", data: "a" });
+    expect(sent).toEqual([]);
+    expect(reached).toEqual(["keydown", "insertText"]);
+  });
+
+  it("leaves third-level shift characters to xterm's keypress path", () => {
+    // Option+key (optionAsMeta off) / AltGr: xterm sends the character from keypress, so the
+    // input event that follows must not be sent a second time.
+    const { textarea, sent, reached } = setup();
+    keydown(textarea, { key: "2", keyCode: 50, altKey: true });
+    input(textarea, { inputType: "insertText", data: "™" });
+    expect(sent).toEqual([]);
+    expect(reached).toEqual(["keydown", "insertText"]);
+  });
+
+  it("leaves input with no keydown behind it to xterm", () => {
+    // Dictation, an on-screen keyboard or the emoji picker.
+    const { textarea, sent, reached } = setup();
+    input(textarea, { inputType: "insertText", data: "😀" });
+    expect(sent).toEqual([]);
+    expect(reached).toEqual(["insertText"]);
+  });
+
+  it("keeps out of real compositions", () => {
+    const { textarea, sent, reached } = setup();
+    textarea.dispatchEvent(new CompositionEvent("compositionstart", { bubbles: true }));
+    keydown(textarea, { key: "Process", keyCode: 229, isComposing: true });
+    input(textarea, { inputType: "insertCompositionText", data: "你", isComposing: true });
+    expect(sent).toEqual([]);
+    expect(reached).toEqual(["compositionstart", "keydown", "insertCompositionText"]);
+  });
+
+  it("stops an IME keydown and its keypress before xterm sees them", () => {
+    const { textarea, reached } = setup();
+    keydown(textarea, { key: "1", keyCode: 229 });
+    keypress(textarea, "1");
+    expect(reached).toEqual([]);
+  });
+
+  it("clears the textarea after a commit", () => {
+    const { textarea } = setup();
+    textarea.value = "1";
+    keydown(textarea, { key: "1", keyCode: 229 });
+    input(textarea, { inputType: "insertText", data: "1" });
+    expect(textarea.value).toBe("");
+  });
+
+  it("stops listening once disposed", () => {
+    const { textarea, sent, dispose } = setup();
+    dispose();
+    keydown(textarea, { key: "1", keyCode: 229 });
+    input(textarea, { inputType: "insertText", data: "1" });
+    expect(sent).toEqual([]);
+  });
+});
diff --git a/src/features/terminal/imeInput.ts b/src/features/terminal/imeInput.ts
new file mode 100644
index 000000000..695b098ad
--- /dev/null
+++ b/src/features/terminal/imeInput.ts
@@ -0,0 +1,104 @@
+/**
+ * Delivers the IME commits xterm loses, and leaves everything else to xterm.
+ *
+ * `CoreBrowserTerminal._inputEvent` ignores an `insertText` event when it is `composed` and
+ * a keydown is still pending (`_keyDownSeen`). That is right for keys xterm already sent
+ * from keydown or keypress (plain typing, Option/AltGr characters), but IMEs that commit
+ * without composition events (Doubao on macOS) inject their text asynchronously while the
+ * keydown that started the commit is still waiting for its keyup, so the commit is dropped.
+ * `CompositionHelper` has the same problem from the other side: it reads a keyCode-229
+ * commit from a `setTimeout(0)` snapshot diff of the textarea, which misses text inserted
+ * after the timer and emits DEL when an IME clears the textarea first.
+ *
+ * So only the commits xterm would lose are taken over:
+ * - a keyCode-229 keydown never reaches xterm, so its deferred textarea diff cannot run;
+ * - while such a keydown is pending, an `insertText` is sent from the event's own `data`
+ *   (not from a value diff), then the textarea is cleared;
+ * - composition input that arrives without a `compositionstart` is sent the same way.
+ *
+ * Everything else stays xterm's: real compositions (`compositionstart` … `compositionend`),
+ * input events for keys xterm already sent, and input with no IME keydown behind it.
+ */
+import { isImeKey } from "@/platform/ime";
+
+/** Commit-shaped input events that xterm's own input path ignores entirely. */
+const COMPOSITION_COMMITS = new Set(["insertFromComposition", "insertCompositionText"]);
+
+export interface TerminalInputOptions {
+  /** The xterm host; capturing here keeps xterm's textarea listeners out of our commits. */
+  host: HTMLElement;
+  textarea: HTMLTextAreaElement;
+  send: (data: string) => void;
+}
+
+/**
+ * Takes input-method commits away from xterm's textarea handling. Returns a disposer.
+ *
+ * `send` receives the committed text once per commit, in order; it is never called for
+ * input a real composition produced (xterm sends that), nor for input xterm handles itself.
+ */
+export function ownTerminalInput({ host, textarea, send }: TerminalInputOptions): () => void {
+  let composing = false;
+  /** The pending keydown went to the input method, so its keypress belongs to it too. */
+  let imeKey = false;
+  /** An IME keydown was seen since the last keyup: its commit is ours to deliver. */
+  let imeDown = false;
+
+  const onKeyDown = (e: KeyboardEvent) => {
+    if (composing) return;
+    imeKey = isImeKey(e);
+    if (imeKey) {
+      // The IME owns this key: xterm must not run its deferred textarea diff or send the
+      // keypress, and the text it commits next is ours.
+      imeDown = true;
+      e.stopPropagation();
+    }
+  };
+
+  // xterm emits a pressed character from keypress; for an IME key that would duplicate the
+  // text the input event delivers.
+  const onKeyPress = (e: KeyboardEvent) => {
+    if (imeKey) e.stopPropagation();
+  };
+
+  const onKeyUp = () => {
+    imeKey = false;
+    imeDown = false;
+  };
+
+  const onInput = (e: InputEvent) => {
+    if (composing || !e.data) return;
+    if (e.inputType === "insertText") {
+      // Without an IME keydown behind it this is xterm's: it drops the event for a key it
+      // already sent (Option/AltGr, plain typing) and delivers the rest (dictation, emoji).
+      if (!imeDown) return;
+    } else if (!COMPOSITION_COMMITS.has(e.inputType)) {
+      return;
+    }
+    e.stopPropagation();
+    send(e.data);
+    textarea.value = "";
+  };
+
+  const onCompositionStart = () => {
+    composing = true;
+  };
+  const onCompositionEnd = () => {
+    composing = false;
+  };
+
+  host.addEventListener("keydown", onKeyDown, true);
+  host.addEventListener("keypress", onKeyPress, true);
+  host.addEventListener("input", onInput, true);
+  host.addEventListener("keyup", onKeyUp, true);
+  textarea.addEventListener("compositionstart", onCompositionStart);
+  textarea.addEventListener("compositionend", onCompositionEnd);
+  return () => {
+    host.removeEventListener("keydown", onKeyDown, true);
+    host.removeEventListener("keypress", onKeyPress, true);
+    host.removeEventListener("input", onInput, true);
+    host.removeEventListener("keyup", onKeyUp, true);
+    textarea.removeEventListener("compositionstart", onCompositionStart);
+    textarea.removeEventListener("compositionend", onCompositionEnd);
+  };
+}
diff --git a/src/features/terminal/session.ts b/src/features/terminal/session.ts
index 70e90bfd1..e44d02ead 100644
--- a/src/features/terminal/session.ts
+++ b/src/features/terminal/session.ts
@@ -14,10 +14,12 @@ import { fitScheduler, settledResize } from "./fit";
 import { installTerminalDrop } from "./drop";
 import { installTerminalPaste, pasteTerminalClipboard } from "./paste";
 import { ImeCommitGate } from "./imeCommit";
+import { ownTerminalInput } from "./imeInput";
 import { findTerminalLinks, resolvePath, type TerminalLink } from "./links";
 import { splitCommandLine } from "@/platform/commandLine";
 import { useProject } from "@/platform/project";
 import { useRemote } from "@/platform/remote";
+import { usePlatform } from "@/platform/platformInfo";
 import { workflowSettings, type TerminalSettingsValid } from "@/platform/workflowSettings";
 import { editorPrefs } from "@/platform/editorSettings";
 import {
@@ -184,7 +186,7 @@ export class TerminalSession {
   private resizeObserver: ResizeObserver | null = null;
   private readonly fitter = fitScheduler(() => this.doFit());
   private readonly ptyResize = settledResize((cols, rows) => this.resizePty(cols, rows));
-  private inputRaf = 0;
+  /** Keystrokes typed while the PTY is still starting; sent as soon as it exists. */
   private pendingInput = "";
   private lastSize = { cols: 0, rows: 0 };
   /** Bumped on restart so late output from a previous PTY is ignored. */
@@ -412,13 +414,22 @@ export class TerminalSession {
   }
 
   /**
-   * Routes a WebKitGTK / fcitx5 IME commit through `ImeCommitGate`: the platform reports the
-   * commit's own keystroke (code 229) and its input event, but reports `compositionstart` only
-   * for composed words — never for the punctuation an IME commits directly.
+   * Delivers the IME commits xterm loses on macOS, and routes a WebKitGTK / fcitx5 commit
+   * through `ImeCommitGate` elsewhere (that platform reports the commit's own keystroke code
+   * 229 and its input event, but reports `compositionstart` only for composed words).
    */
   private watchImeCommit() {
     const textarea = this.term.textarea;
     if (!textarea) return;
+    // WKWebView: xterm drops commits IMEs without composition events inject (Doubao) and
+    // misses text that lands after its textarea snapshot. Deliver those here.
+    if (usePlatform.getState().os === "macos") {
+      this.disposables.push({
+        dispose: ownTerminalInput({ host: this.host, textarea, send: (data) => this.send(data) }),
+      });
+      return;
+    }
+    // WebKitGTK (Linux) and WebView2 keep the fcitx5 deduplication gate.
     const onKeyDown = (e: KeyboardEvent) => {
       if (e.keyCode === 229) this.ime.begin();
       else this.ime.keystroke();
@@ -513,6 +524,7 @@ export class TerminalSession {
       }
       this.ptyId = info.id;
       this.update({ status: "running", title: info.title || "Local" });
+      this.flushPendingInput();
     } catch (e) {
       this.term.writeln(`\x1b[31mFailed to start terminal: ${e instanceof Error ? e.message : String(e)}\x1b[0m`);
       this.term.writeln(RESTART_HINT);
@@ -557,26 +569,36 @@ export class TerminalSession {
   restart() {
     if (this.snapshot.status === "running" || this.snapshot.status === "starting") return;
     this.term.write("\r\n");
+    this.pendingInput = "";
     this.update({ status: "idle" });
     void this.start();
   }
 
-  /** Sends input to the PTY, coalescing rapid keystrokes per animation frame. */
+  /**
+   * Sends input to the PTY. Keystrokes are not coalesced: WebKit delivers at most one key
+   * event per frame already, and a frame-based batch only made input wait for rendering.
+   */
   input(data: string) {
+    if (!data) return;
     const status = this.snapshot.status;
     if (status === "exited" || status === "error") {
       if (data === "\r") this.restart();
       return;
     }
-    if (this.ptyId === null) return;
-    this.pendingInput += data;
-    if (this.inputRaf) return;
-    this.inputRaf = requestAnimationFrame(() => {
-      this.inputRaf = 0;
-      const chunk = this.pendingInput;
-      this.pendingInput = "";
-      if (chunk && this.ptyId !== null) void commands.termWrite(this.ptyId, chunk);
-    });
+    if (this.ptyId === null) {
+      // The shell is still being spawned (tens of ms); keep the keystrokes and send them
+      // once the PTY exists instead of dropping them.
+      this.pendingInput += data;
+      return;
+    }
+    void commands.termWrite(this.ptyId, data);
+  }
+
+  /** Sends keystrokes buffered while the PTY was starting. */
+  private flushPendingInput() {
+    const queued = this.pendingInput;
+    this.pendingInput = "";
+    if (queued && this.ptyId !== null) void commands.termWrite(this.ptyId, queued);
   }
 
   /** Writes input immediately (shortcuts translated outside xterm). */
@@ -663,7 +685,7 @@ export class TerminalSession {
     this.disposed = true;
     this.fitter.cancel();
     this.ptyResize.cancel();
-    cancelAnimationFrame(this.inputRaf);
+    this.pendingInput = "";
     this.resizeObserver?.disconnect();
     this.host.removeEventListener("mousedown", this.onMiddleClick);
     if (this.ptyId !== null) void commands.termKill(this.ptyId);
diff --git a/src/features/vcs/CommitView.tsx b/src/features/vcs/CommitView.tsx
index bd17083ae..51054122f 100644
--- a/src/features/vcs/CommitView.tsx
+++ b/src/features/vcs/CommitView.tsx
@@ -3,6 +3,7 @@
  * parts also make the Git window's Local Changes / Stash tabs and the Commit dialog.
  */
 import { useWorkflowSettings } from "@/platform/workflowSettings";
+import { formatBinding, isMacHost } from "@/platform/keymap";
 import { useCallback, useEffect, useMemo, useRef, useState, type MouseEvent, type PointerEvent } from "react";
 import { tx } from "@/platform/i18n";
 import clsx from "clsx";
@@ -224,8 +225,15 @@ export function listMenu(id: string, active: boolean, files: readonly FileStatus
   ];
 }
 
+/** Paths Delete… applies to: only when every selected file is unversioned (versioned ones are rolled back). */
+export function deletableUnversioned(nodes: ChangeNode[]): string[] {
+  const files = filesOf(nodes);
+  return files.length && files.every((f) => f.unstaged === "untracked") ? files.map((f) => f.path) : [];
+}
+
 export function nodeMenu(nodes: ChangeNode[], repos: readonly string[]): MenuItem[] {
   const files = filesOf(nodes);
+  const deletable = deletableUnversioned(nodes);
   const paths = files.map((f) => f.path);
   const first = nodes.find((n) => n.type === "file");
   const untracked = files.filter((f) => f.unstaged === "untracked");
@@ -248,9 +256,15 @@ export function nodeMenu(nodes: ChangeNode[], repos: readonly string[]): MenuIte
     ...(untracked.length
       ? [
           { kind: "action" as const, action: "vcs.addToVcs", arg: untracked.map((f) => f.path) },
-          // Only when every selected file is unversioned: versioned ones are rolled back, not deleted.
-          ...(untracked.length === files.length
-            ? [{ label: "Delete…", icon: "trash", run: () => void deleteUnversioned(untracked.map((f) => f.path)) }]
+          ...(deletable.length
+            ? [
+                {
+                  label: "Delete…",
+                  icon: "trash",
+                  shortcut: formatBinding(isMacHost() ? "Backspace" : "Delete"),
+                  run: () => void deleteUnversioned(deletable),
+                },
+              ]
             : []),
         ]
       : []),
@@ -518,11 +532,17 @@ export function ChangesTree({ mode }: { mode: "commit" | "local" | "dialog" }) {
             e.stopPropagation();
             toggle(selectedNodes());
           } else if ((e.key === "Delete" || e.key === "Backspace") && !e.metaKey) {
-            const group = selectedNodes().find((x) => x.type === "group" && x.changelist);
+            const nodes = selectedNodes();
+            const group = nodes.find((x) => x.type === "group" && x.changelist);
+            const deletable = group ? [] : deletableUnversioned(nodes);
             if (group?.changelist) {
               e.preventDefault();
               e.stopPropagation();
               void executeAction("vcs.changelist.delete", group.changelist);
+            } else if (deletable.length) {
+              e.preventDefault();
+              e.stopPropagation();
+              void deleteUnversioned(deletable);
             }
           } else if (e.key === "F4") {
             const n = selectedNodes().find((x) => x.type === "file");
diff --git a/src/features/vcs/DiffEditor.tsx b/src/features/vcs/DiffEditor.tsx
index b1b83e2d0..d9c8dc580 100644
--- a/src/features/vcs/DiffEditor.tsx
+++ b/src/features/vcs/DiffEditor.tsx
@@ -28,7 +28,7 @@ import {
 import { attachDocument, embeddedEditorExtensions, type DocumentAttachment } from "@/editor/api";
 import { setFindOpen } from "@/editor/core/cm/find";
 import { FindPanel, searchAgain, seedFind, type FindTarget } from "@/editor/core/view/FindBar";
-import { setContext } from "@/platform/context";
+import { getContext, setContext } from "@/platform/context";
 import { call, commands } from "@/platform/ipc";
 import { bindingsFor, normalizeBinding, shortcutLabel, strokeOf } from "@/platform/keymap";
 import { tx } from "@/platform/i18n";
@@ -62,6 +62,8 @@ import {
   type DiffSide,
 } from "./diffInput";
 import { diffAnnotations } from "./diffAnnotations";
+import { annotationsShown, blameSlot, toggleAnnotations } from "./blame";
+import { diffBlameTarget } from "./diffBlame";
 import { changedChainNeighbour } from "./diffNavigation";
 import { movedCodeHighlights } from "./movedCode";
 import {
@@ -380,6 +382,7 @@ export function DiffEditor({ input, toolbarActions }: { input: EditorInput; tool
       // Esc closes the find bar before it collapses the selection (a found match); open popups go first.
       Prec.high(keymap.of([{ key: "Escape", run: () => findEscape.current() }])),
       lang,
+      blameSlot(),
       att?.extension ?? [],
       editable ? [editableExtensions(), embeddedEditorExtensions(path)] : [],
       notes
@@ -874,19 +877,41 @@ export function DiffEditor({ input, toolbarActions }: { input: EditorInput; tool
       }),
     ]);
   };
-  /** The panes' right-click menu: the contributions' items for the clicked line (none: the default menu). */
+  /** Annotate with Git Blame for a pane, by that side's own revision. */
+  const blameItems = (pane: DiffViewerPane) => {
+    const target = diffBlameTarget(pane.side === "left" ? left : right, path, !!getContext().vcsAvailable);
+    if (!target) return [];
+    const view = pane.view;
+    const text = target.revision ? view.state.doc.toString() : undefined;
+    return [
+      {
+        label: annotationsShown(view) ? "Close Annotations" : "Annotate with Git Blame",
+        run: () => void toggleAnnotations(view, target.path, text, target.revision),
+      },
+    ];
+  };
+  /**
+   * The panes' right-click menu: the contributions' items for the clicked line and Git annotations
+   * (none: the default menu). The divider between the panes acts on the pane focused last.
+   */
   const onContextMenu = (e: MouseEvent) => {
-    const pane = viewerRef.current?.panes().find((p) => p.view.dom.contains(e.target as Node | null));
-    if (!pane) return;
-    const pos = pane.view.posAtCoords({ x: e.clientX, y: e.clientY }, false);
-    const line = pane.view.state.doc.lineAt(pos).number - 1;
-    const items = contribs.flatMap((c) => {
-      const list = c.contextMenuItems?.({ side: pane.side, line }) ?? [];
-      return list.length ? [...list, { kind: "separator" } as const] : [];
-    });
-    if (!items.length) return;
+    const viewer = viewerRef.current;
+    if (!viewer || e.defaultPrevented) return;
+    const hit = viewer.panes().find((p) => p.view.dom.contains(e.target as Node | null));
+    const pane = hit ?? viewer.focusedPane();
+    const line = hit
+      ? hit.view.state.doc.lineAt(hit.view.posAtCoords({ x: e.clientX, y: e.clientY }, false)).number - 1
+      : -1;
+    const groups = [
+      ...(hit ? contribs.map((c) => c.contextMenuItems?.({ side: hit.side, line }) ?? []) : []),
+      blameItems(pane),
+    ].filter((g) => g.length);
+    if (!groups.length) return;
     e.preventDefault();
-    showContextMenu(e, items.slice(0, -1));
+    showContextMenu(
+      e,
+      groups.flatMap((g, i) => (i ? [{ kind: "separator" } as const, ...g] : g)),
+    );
   };
   const viewerOf = () => viewerRef.current;
   const nav = useRef<DiffNavigator>({
diff --git a/src/features/vcs/GitLog.tsx b/src/features/vcs/GitLog.tsx
index 89edb7bb5..be7b59f92 100644
--- a/src/features/vcs/GitLog.tsx
+++ b/src/features/vcs/GitLog.tsx
@@ -49,7 +49,6 @@ import {
 import { hasPrimaryModifier } from "@/platform/keymap";
 import { laneColor, reachableFrom, type GraphRow, type GraphSegment } from "./graph";
 import { nextSpeedMatch } from "./logSearch";
-import { LogIndexStatus } from "./logIndex";
 import { presentLogGraph } from "./logPresentation";
 import {
   closeLogTab,
@@ -328,7 +327,6 @@ export function LogView() {
       <SplitPanel id="commits" defaultSize="54%" minSize="25%">
         <div className={styles.log}>
           <FilterBar />
-          <LogIndexStatus repositories={repo} />
           <CommitList />
         </div>
       </SplitPanel>
@@ -1091,6 +1089,8 @@ export function viewOptionsMenu(o: LogOptions): MenuItem[] {
         toggle("Date", o, "showDate"),
         toggle("Hash", o, "showHash"),
         toggle("Signature", o, "showSignature"),
+        { kind: "separator" },
+        toggle("Column Headers", o, "showColumnHeaders"),
       ],
     },
     { kind: "separator" },
@@ -1604,15 +1604,17 @@ function CommitList() {
           );
         }}
       >
-        <div className={clsx(styles.row, styles.columnHeader)} style={{ minWidth }}>
-          {opts.showRepository && useVcs.getState().roots.length > 1 && (
-            <span className={styles.colRepository}>{tx("Repository")}</span>
-          )}
-          <span className={styles.colSubject}>{tx("Commit")}</span>
-          {columns.map((column) => (
-            <LogColumnHeader key={column.id} column={column} columns={columns} options={opts} />
-          ))}
-        </div>
+        {opts.showColumnHeaders && (
+          <div className={clsx(styles.row, styles.columnHeader)} style={{ minWidth }}>
+            {opts.showRepository && useVcs.getState().roots.length > 1 && (
+              <span className={styles.colRepository}>{tx("Repository")}</span>
+            )}
+            <span className={styles.colSubject}>{tx("Commit")}</span>
+            {columns.map((column) => (
+              <LogColumnHeader key={column.id} column={column} columns={columns} options={opts} />
+            ))}
+          </div>
+        )}
         {!commits.length && !loading && finished && (
           <div className={styles.message}>{headCommit ? tx("No commits match the filters") : tx("No commits yet")}</div>
         )}
diff --git a/src/features/vcs/__tests__/deleteUnversioned.test.ts b/src/features/vcs/__tests__/deleteUnversioned.test.ts
index 9e517f619..63fa36d94 100644
--- a/src/features/vcs/__tests__/deleteUnversioned.test.ts
+++ b/src/features/vcs/__tests__/deleteUnversioned.test.ts
@@ -13,7 +13,7 @@ vi.mock("../dialogs", async (original) => ({
   confirmDialog: mocks.confirm,
 }));
 
-const { nodeMenu } = await import("../CommitView");
+const { deletableUnversioned, nodeMenu } = await import("../CommitView");
 const { deleteUnversioned } = await import("../changeOps");
 
 const file = (rel: string, unstaged: FileStatus["unstaged"]): ChangeNode => {
@@ -36,6 +36,16 @@ describe("Delete… for unversioned files", () => {
     expect(deleteItem(nodeMenu([file("c.txt", "modified")], ["/p"]))).toBeUndefined();
   });
 
+  it("shows the Delete key and gives the key handler the same paths", () => {
+    expect(deleteItem(nodeMenu([file("a.txt", "untracked")], ["/p"]))).toMatchObject({ shortcut: "⌫" });
+    expect(deletableUnversioned([file("a.txt", "untracked"), file("b.txt", "untracked")])).toEqual([
+      "/p/a.txt",
+      "/p/b.txt",
+    ]);
+    expect(deletableUnversioned([file("a.txt", "untracked"), file("c.txt", "modified")])).toEqual([]);
+    expect(deletableUnversioned([])).toEqual([]);
+  });
+
   it("asks first, then deletes each file", async () => {
     mocks.confirm.mockResolvedValueOnce(false);
     await deleteUnversioned(["/p/a.txt"]);
diff --git a/src/features/vcs/__tests__/graph.test.ts b/src/features/vcs/__tests__/graph.test.ts
index 97464ef7e..5b575aa50 100644
--- a/src/features/vcs/__tests__/graph.test.ts
+++ b/src/features/vcs/__tests__/graph.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { computeGraph, straightenLaneChanges } from "../graph";
+import { compactLanes, computeGraph, straightenLaneChanges, type GraphRow } from "../graph";
 
 const c = (id: string, ...parents: string[]) => ({ id, parents });
 
@@ -106,3 +106,61 @@ describe("straightenLaneChanges", () => {
     expect(rows[2]!.up[0]!.fromX).toBeUndefined();
   });
 });
+
+describe("compactLanes", () => {
+  const row = (lane: number, up: [number, number][], down: [number, number][], width = 9): GraphRow => ({
+    lane,
+    color: 0,
+    up: up.map(([from, to]) => ({ from, to, color: 0 })),
+    down: down.map(([from, to]) => ({ from, to, color: 0 })),
+    width,
+  });
+
+  it("packs the lanes of each row side by side, in their order", () => {
+    // Lanes 2 and 7 (branch layout leaves the slots between them empty); 7 merges into 2.
+    const rows = compactLanes([
+      row(
+        7,
+        [],
+        [
+          [2, 2],
+          [7, 7],
+        ],
+      ),
+      row(
+        2,
+        [
+          [2, 2],
+          [7, 2],
+        ],
+        [[2, 2]],
+      ),
+      row(2, [[2, 2]], []),
+    ]);
+    expect(rows.map((r) => r.lane)).toEqual([1, 0, 0]);
+    expect(rows.map((r) => r.width)).toEqual([2, 2, 1]);
+    expect(rows[0]!.down.map((s) => [s.from, s.to])).toEqual([
+      [0, 0],
+      [1, 1],
+    ]);
+    expect(rows[1]!.up.map((s) => [s.from, s.to])).toEqual([
+      [0, 0],
+      [1, 0],
+    ]);
+  });
+
+  it("keeps lines joined across rows when a lane is freed in between", () => {
+    const laid = computeGraph([
+      { id: "a", parents: ["c"], refs: ["a"] },
+      { id: "b", parents: ["c"], refs: ["b"] },
+      { id: "x", parents: ["c"], refs: ["x"] },
+      { id: "c", parents: [], refs: ["main"] },
+    ]).rows;
+    const rows = compactLanes(laid);
+    for (let r = 0; r + 1 < rows.length; r++) {
+      const below = new Set(rows[r]!.down.map((s) => s.to));
+      expect(new Set(rows[r + 1]!.up.map((s) => s.from))).toEqual(below);
+      expect(Math.max(...below)).toBe(below.size - 1);
+    }
+  });
+});
diff --git a/src/features/vcs/__tests__/logUiFeatures.test.tsx b/src/features/vcs/__tests__/logUiFeatures.test.tsx
index 2159cf57b..f6bc94d39 100644
--- a/src/features/vcs/__tests__/logUiFeatures.test.tsx
+++ b/src/features/vcs/__tests__/logUiFeatures.test.tsx
@@ -23,7 +23,6 @@ vi.mock("@/platform/ipc", async (original) => {
         status: "ok",
         data: await Promise.all(ids.map(async () => (await api.details()).data)),
       }),
-      vcsLogIndex: () => ok({ indexed: 0, total: 0, running: false }),
       vcsDiffRevisions: (...args: unknown[]) => api.diff(...args),
     },
   };
@@ -149,7 +148,14 @@ describe("log controls", () => {
     expect(screen.getByRole("status")).toHaveTextContent("b");
   });
 
+  it("hides the column headers unless View Options shows them", async () => {
+    render(<LogView />);
+    await screen.findByRole("listbox", { name: "Commits" });
+    expect(screen.queryByRole("separator", { name: "Resize Author column" })).toBeNull();
+  });
+
   it("resizes and reorders columns using the keyboard", async () => {
+    useLogOptions.setState({ showColumnHeaders: true });
     render(<LogView />);
     const author = await screen.findByRole("separator", { name: "Resize Author column" });
     fireEvent.keyDown(author, { key: "ArrowRight" });
diff --git a/src/features/vcs/__tests__/show-diff-chain.test.ts b/src/features/vcs/__tests__/show-diff-chain.test.ts
index 5a79094fe..b917a11e6 100644
--- a/src/features/vcs/__tests__/show-diff-chain.test.ts
+++ b/src/features/vcs/__tests__/show-diff-chain.test.ts
@@ -1,6 +1,7 @@
 import { afterEach, beforeEach, expect, it, vi } from "vitest";
 import type { FileStatus } from "@/bindings";
 import { getAction } from "@/platform/actions";
+import { setContext } from "@/platform/context";
 import { registerVcsActions } from "../actions";
 import { useVcs } from "../store";
 import { useCommit } from "../commitStore";
@@ -8,10 +9,11 @@ import { initialChangelists, useChangelists } from "../changelists";
 import { chainNeighbour } from "../diffInput";
 
 const opened = vi.hoisted(() => vi.fn());
+const project = vi.hoisted(() => ({ paths: [] as string[] }));
 vi.mock("@/workbench/contributions", async (original) => ({
   ...(await original<typeof import("@/workbench/contributions")>()),
   editorService: () => ({ openInput: opened }),
-  projectViewSelection: () => [],
+  projectViewSelection: () => project.paths,
 }));
 vi.mock("../comparePaths", () => ({ showDirectoryWorkingDiff: async () => false }));
 
@@ -29,9 +31,11 @@ let unregister: () => void;
 
 beforeEach(() => {
   opened.mockClear();
+  project.paths = [];
+  setContext("activeToolWindow", "");
   const files = [status("z.ts"), status("b.ts"), status("a.ts"), status("other.ts")];
   useVcs.setState({ root: "/repo", roots: ["/repo"], status: files, byPath: new Map(files.map((f) => [f.path, f])) });
-  useCommit.setState({ groupByDir: false });
+  useCommit.setState({ groupByDir: false, selection: [] });
   const state = initialChangelists();
   state.lists.push({ id: "other", name: "Other", comment: "" });
   state.files = { "other.ts": "other" };
@@ -41,6 +45,7 @@ beforeEach(() => {
 
 afterEach(() => {
   unregister();
+  setContext("activeToolWindow", "");
   useVcs.setState(vcs);
   useCommit.setState(commit);
   useChangelists.setState(lists);
@@ -90,3 +95,20 @@ it("keeps repository grouping in a changelist's chain", async () => {
     "/repo/module/b.ts",
   ]);
 });
+
+it("shows the selected change rather than a Project view selection kept from earlier", async () => {
+  // The Project view keeps its selection while the Commit window has focus: ⌘D must open
+  // the file selected in the changes tree, not the one still selected there.
+  project.paths = ["/repo/z.ts"];
+  setContext("activeToolWindow", "commit");
+  useCommit.setState({ selection: ["/repo/b.ts"] });
+  await getAction("vcs.showDiff")!.run({ arg: undefined, ctx: { vcsAvailable: true } });
+  expect(opened.mock.calls[0]![0].data.path).toBe("/repo/b.ts");
+});
+
+it("shows a Project view selection outside the changes tree", async () => {
+  project.paths = ["/repo/z.ts"];
+  setContext("activeToolWindow", "project");
+  await getAction("vcs.showDiff")!.run({ arg: undefined, ctx: { vcsAvailable: true } });
+  expect(opened.mock.calls[0]![0].data.path).toBe("/repo/z.ts");
+});
diff --git a/src/features/vcs/actions.tsx b/src/features/vcs/actions.tsx
index 032119654..a1ca25733 100644
--- a/src/features/vcs/actions.tsx
+++ b/src/features/vcs/actions.tsx
@@ -75,16 +75,34 @@ export const commitWindowFocused = () => {
   return active === "commit" || (active === "git" && useGitLog.getState().tab === "changes");
 };
 
-/** Files the current context refers to: argument, commit view selection, or the active file. */
-function contextPaths(arg: unknown): string[] {
+/** The action's own paths, or the changes tree's selection while the tree has focus. */
+function changedPaths(arg: unknown): string[] {
   const explicit = argPaths(arg);
   if (explicit?.length) return explicit;
   const sel = useCommit.getState().selection;
-  if (commitWindowFocused() && sel.length) return sel;
+  return commitWindowFocused() ? sel : [];
+}
+
+/** Files the current context refers to: argument, commit view selection, or the active file. */
+function contextPaths(arg: unknown): string[] {
+  const changed = changedPaths(arg);
+  if (changed.length) return changed;
   const active = maybeEditorService()?.activePath();
   return active ? [active] : [];
 }
 
+/**
+ * Paths a selection-based action targets: the argument, else the changes tree's selection,
+ * else the Project view's — it keeps its selection while another view has focus — else the
+ * active file.
+ */
+function selectedPaths(arg: unknown): string[] {
+  const changed = changedPaths(arg);
+  if (changed.length) return changed;
+  const project = projectViewSelection();
+  return project.length ? project : contextPaths(arg);
+}
+
 function showGitWindow() {
   toolWindowService().show("git", true);
 }
@@ -321,8 +339,7 @@ export function registerVcsActions(): () => void {
         if (ctx.shelfFocus && arg === undefined) return showShelfDiff();
         const line =
           arg && typeof arg === "object" && "line" in arg ? Number((arg as { line: unknown }).line) : undefined;
-        const selection = arg === undefined ? projectViewSelection() : [];
-        const paths = selection.length ? selection : contextPaths(arg);
+        const paths = selectedPaths(arg);
         if (!paths.length) {
           notifications().notify({ group: "vcs", level: "info", title: "Select a changed file to show its diff" });
           return;
@@ -354,8 +371,7 @@ export function registerVcsActions(): () => void {
       icon: "diff",
       when: VCS,
       run: async ({ arg }) => {
-        const selection = arg === undefined ? projectViewSelection() : [];
-        const paths = selection.length ? selection : contextPaths(arg);
+        const paths = selectedPaths(arg);
         if (!paths.length) {
           notifications().notify({ group: "vcs", level: "info", title: "Open or select a file or folder to compare" });
           return;
diff --git a/src/features/vcs/cm.ts b/src/features/vcs/cm.ts
index 131c06af0..07ae5810f 100644
--- a/src/features/vcs/cm.ts
+++ b/src/features/vcs/cm.ts
@@ -270,9 +270,10 @@ export const viewerTheme = EditorView.theme(
     "&.cm-openidea-ligatures .cm-scroller": { fontVariantLigatures: "normal" },
     ".cm-content": { caretColor: "var(--caret, var(--fg-strong))", WebkitUserSelect: "text", userSelect: "text" },
     ...caretStyles,
-    "&.cm-focused > .cm-scroller > .cm-selectionLayer .cm-selectionBackground, .cm-selectionBackground, ::selection": {
-      backgroundColor: "var(--bg-selected-strong)",
-    },
+    "&.cm-focused > .cm-scroller > .cm-selectionLayer .cm-selectionBackground, .cm-selectionBackground, ::selection, .cm-openidea-selected, &.cm-focused .cm-openidea-selected":
+      {
+        backgroundColor: "var(--bg-selected-strong)",
+      },
     ".cm-activeLine": { backgroundColor: "var(--bg-current-line)" },
     ".cm-gutters": {
       backgroundColor: "var(--bg-app)",
diff --git a/src/features/vcs/common.module.css b/src/features/vcs/common.module.css
index cadf6f9d5..05065dc61 100644
--- a/src/features/vcs/common.module.css
+++ b/src/features/vcs/common.module.css
@@ -111,6 +111,10 @@
   border-radius: var(--radius-small);
 }
 /* Push dialogs: the list fills the body so a resizable window shows more rows. */
+.pushDialog > [data-dialog-body] {
+  display: flex;
+  flex-direction: column;
+}
 .pushTreeWrap {
   flex: 1;
   min-height: 220px;
@@ -127,6 +131,7 @@
 }
 /* Push dialogs: the outgoing commits' changed files below the commits, the diff beside them. */
 .pushChanges {
+  flex: none;
   display: flex;
   flex-direction: column;
   min-height: 0;
@@ -300,6 +305,18 @@
 .manageRowSelected:hover {
   background: var(--bg-list-selected);
 }
+/* A fixed slot, so the names line up whether or not a row is marked. */
+.worktreeMark {
+  display: flex;
+  flex: none;
+  width: 14px;
+  margin-right: -4px;
+}
+/* The branch keeps its width; the path is what gets cut short. */
+.worktreeName {
+  flex: none;
+  max-width: 40%;
+}
 
 .comparisonDialog > [data-dialog-body] {
   display: flex;
diff --git a/src/features/vcs/diffBlame.test.ts b/src/features/vcs/diffBlame.test.ts
new file mode 100644
index 000000000..f6e7369a2
--- /dev/null
+++ b/src/features/vcs/diffBlame.test.ts
@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest";
+import { diffBlameTarget } from "./diffBlame";
+
+describe("diffBlameTarget", () => {
+  it("blames a revision on its own history, at the path it had there", () => {
+    expect(diffBlameTarget({ type: "rev", rev: "abc123^" }, "/p/A.java", true)).toEqual({
+      path: "/p/A.java",
+      revision: "abc123^",
+    });
+    expect(diffBlameTarget({ type: "rev", rev: "abc123", path: "/p/Old.java" }, "/p/A.java", true)).toEqual({
+      path: "/p/Old.java",
+      revision: "abc123",
+    });
+  });
+
+  it("blames the index on HEAD and the working file like the editor", () => {
+    expect(diffBlameTarget({ type: "rev", rev: ":0" }, "/p/A.java", true)).toEqual({
+      path: "/p/A.java",
+      revision: "HEAD",
+    });
+    expect(diffBlameTarget({ type: "worktree" }, "/p/A.java", true)).toEqual({ path: "/p/A.java" });
+  });
+
+  it("offers nothing for content outside Git", () => {
+    for (const side of [
+      { type: "file", path: "/p/B.java" },
+      { type: "text", text: "x", label: "Clipboard" },
+      { type: "history", id: "1", label: "Local History" },
+    ] as const)
+      expect(diffBlameTarget(side, "/p/A.java", true)).toBeNull();
+    expect(diffBlameTarget({ type: "worktree" }, "/p/A.java", false)).toBeNull();
+  });
+});
diff --git a/src/features/vcs/diffBlame.ts b/src/features/vcs/diffBlame.ts
new file mode 100644
index 000000000..cc8beeea0
--- /dev/null
+++ b/src/features/vcs/diffBlame.ts
@@ -0,0 +1,27 @@
+import type { DiffSide } from "./diffInput";
+
+/** What `git blame` annotates a diff side with. */
+export interface DiffBlameTarget {
+  /** The file at that side's revision (it may have been renamed since). */
+  path: string;
+  /** Blame history; unset for the working file, which follows HEAD and edits like the editor's annotations. */
+  revision?: string;
+}
+
+/**
+ * The blame for one side of a diff: a revision blames its own history, the working file the
+ * file on disk; Compare Files, Local History and plain texts are not Git content.
+ * The index (`:0`) is not a revision `git blame` takes, so its text is blamed on HEAD and the
+ * lines staged since show as not committed.
+ */
+export function diffBlameTarget(side: DiffSide, path: string, vcsAvailable: boolean): DiffBlameTarget | null {
+  if (!vcsAvailable) return null;
+  switch (side.type) {
+    case "rev":
+      return { path: side.path ?? path, revision: side.rev.startsWith(":") ? "HEAD" : side.rev };
+    case "worktree":
+      return { path };
+    default:
+      return null;
+  }
+}
diff --git a/src/features/vcs/gitMenuDialogs.tsx b/src/features/vcs/gitMenuDialogs.tsx
index cc19fb228..5fd455c17 100644
--- a/src/features/vcs/gitMenuDialogs.tsx
+++ b/src/features/vcs/gitMenuDialogs.tsx
@@ -5,12 +5,13 @@ import type { Branch, MergeOptions, Remote, Worktree } from "@/bindings";
 import { executeAction } from "@/platform/actions";
 import { call, commands } from "@/platform/ipc";
 import { notifications } from "@/workbench/contributions";
-import { Checkbox, Dialog, IconButton, Input, Select, T, type SelectOption } from "@/ui";
+import { Checkbox, Dialog, Icon, IconButton, Input, Select, T, type SelectOption } from "@/ui";
 import { sortLocal, sortRemote } from "./branches";
 import { conflictActions, openConflictsInstead, validateBranchName } from "./branchOps";
 import { confirmDialog, openDialog } from "./dialogs";
 import { errorMessage, runOp, runRemote, saveAll } from "./ops";
 import { currentRepo, loadBranches, refreshNow, repoName, selectRepo, useVcs } from "./store";
+import { isCurrentWorktree } from "./worktrees";
 import styles from "./common.module.css";
 import { tx } from "@/platform/i18n";
 
@@ -660,7 +661,13 @@ export function WorktreesPanel({ className, listClassName }: { className?: strin
             onClick={() => setSelected(w.path)}
             onDoubleClick={() => void executeAction("file.openProjectPath", w.path)}
           >
-            <span className={styles.fileName}>{w.branch ?? (w.head ? w.head.slice(0, 8) : <T>(bare)</T>)}</span>
+            {/* The worktree this window works in, as IDEA marks it. */}
+            <span className={styles.worktreeMark}>
+              {isCurrentWorktree(w.path, repo) && <Icon name="check" size={14} label={tx("Current worktree")} />}
+            </span>
+            <span className={clsx(styles.fileName, styles.worktreeName)}>
+              {w.branch ?? (w.head ? w.head.slice(0, 8) : <T>(bare)</T>)}
+            </span>
             <span className={clsx(styles.fileDir, styles.mono)}>{w.path}</span>
             {(w.main || w.locked || w.prunable) && (
               <span className={styles.fileDir}>{w.main ? "main" : w.locked ? tx("locked") : tx("prunable")}</span>
diff --git a/src/features/vcs/graph.ts b/src/features/vcs/graph.ts
index 1f160952f..b6e84dd53 100644
--- a/src/features/vcs/graph.ts
+++ b/src/features/vcs/graph.ts
@@ -506,6 +506,30 @@ export function hideLongEdges(rows: readonly GraphRow[], minLength = LONG_EDGE):
   return out;
 }
 
+/**
+ * Packs each row's lanes side by side, in their order: lanes laid out by branch leave
+ * gaps (one per branch) and hidden long edges free theirs. Each row boundary and each
+ * node level is packed on its own; adjacent rows share the boundary, so lines stay joined.
+ */
+export function compactLanes(rows: readonly GraphRow[]): GraphRow[] {
+  const ranks = (lanes: Iterable<number>) => new Map([...new Set(lanes)].sort((a, b) => a - b).map((l, i) => [l, i]));
+  const boundaries = Array.from({ length: rows.length + 1 }, (_, r) =>
+    ranks([...(rows[r]?.up.map((s) => s.from) ?? []), ...(rows[r - 1]?.down.map((s) => s.to) ?? [])]),
+  );
+  return rows.map((row, r) => {
+    const node = ranks([row.lane, ...row.up.map((s) => s.to), ...row.down.map((s) => s.from)]);
+    const top = boundaries[r]!;
+    const bottom = boundaries[r + 1]!;
+    return {
+      ...row,
+      lane: node.get(row.lane)!,
+      up: row.up.map((s) => ({ ...s, from: top.get(s.from)!, to: node.get(s.to)! })),
+      down: row.down.map((s) => ({ ...s, from: node.get(s.from)!, to: bottom.get(s.to)! })),
+      width: Math.max(node.size, top.size, bottom.size),
+    };
+  });
+}
+
 /**
  * Draws a lane change as one straight diagonal across the row boundary, like IDEA: a half-row
  * segment that changes lane and the vertical half of the neighbouring row that continues it meet
diff --git a/src/features/vcs/logIndex.tsx b/src/features/vcs/logIndex.tsx
deleted file mode 100644
index 33a0a73f7..000000000
--- a/src/features/vcs/logIndex.tsx
+++ /dev/null
@@ -1,110 +0,0 @@
-import { useEffect } from "react";
-import { create } from "zustand";
-import type { LogIndexProgress } from "@/bindings";
-import { call, commands, nextRequestId, type RequestId } from "@/platform/ipc";
-import { tx } from "@/platform/i18n";
-import { useVcs } from "./store";
-import { IconButton } from "@/ui";
-
-interface Job {
-  version?: number;
-  restart?: boolean;
-  users: number;
-  request: RequestId | null;
-  paused: boolean;
-  progress: LogIndexProgress;
-  timer?: ReturnType<typeof setInterval>;
-}
-const jobs = new Map<string, Job>();
-const revision = create<{ value: number }>(() => ({ value: 0 }));
-const notify = () => revision.setState((s) => ({ value: s.value + 1 }));
-function start(repo: string, job: Job) {
-  if (job.paused) return;
-  if (job.request != null) {
-    job.restart = true;
-    return;
-  }
-  const request = nextRequestId();
-  job.request = request;
-  job.progress = { ...job.progress, running: true };
-  job.timer = setInterval(() => {
-    void call(commands.vcsLogIndex(repo, null))
-      .then((progress) => {
-        if (job.request === request) {
-          job.progress = progress;
-          notify();
-        }
-      })
-      .catch(() => undefined);
-  }, 750);
-  void call(commands.vcsLogIndex(repo, request))
-    .then(
-      (progress) => {
-        job.progress = progress;
-      },
-      () => {
-        job.progress = { ...job.progress, running: false };
-      },
-    )
-    .finally(() => {
-      if (job.request !== request) return;
-      job.request = null;
-      clearInterval(job.timer);
-      if (job.restart && job.users && !job.paused) {
-        job.restart = false;
-        start(repo, job);
-      }
-      notify();
-    });
-  notify();
-}
-
-/** Visible log scopes share one background job per repository. */
-export function LogIndexStatus({ repositories }: { repositories: readonly string[] }) {
-  revision((s) => s.value);
-  const version = useVcs((s) => s.version);
-  useEffect(() => {
-    for (const repo of repositories) {
-      const job: Job = jobs.get(repo) ?? {
-        users: 0,
-        request: null,
-        paused: false,
-        progress: { indexed: 0, total: 0, running: false },
-      };
-      jobs.set(repo, job);
-      const first = job.users++ === 0;
-      if (first || job.version !== version) {
-        job.version = version;
-        start(repo, job);
-      }
-    }
-    return () => {
-      for (const repo of repositories) {
-        const job = jobs.get(repo)!;
-        if (--job.users === 0) {
-          clearInterval(job.timer);
-          if (job.request != null) void commands.cancelRequest(job.request).catch(() => undefined);
-        }
-      }
-    };
-  }, [repositories, version]);
-  return repositories.map((repo) => {
-    const job = jobs.get(repo);
-    if (!job || (!job.paused && !job.progress.running)) return null;
-    return (
-      <div key={repo} role="status" style={{ display: "flex", alignItems: "center", gap: 6 }}>
-        {tx`Indexing Git log: ${job.progress.indexed} / ${job.progress.total}`}
-        <IconButton
-          icon={job.paused ? "play" : "pause"}
-          title={job.paused ? "Resume Indexing" : "Pause Indexing"}
-          onClick={() => {
-            job.paused = !job.paused;
-            if (job.paused && job.request != null) void commands.cancelRequest(job.request).catch(() => undefined);
-            else start(repo, job);
-            notify();
-          }}
-        />
-      </div>
-    );
-  });
-}
diff --git a/src/features/vcs/logOptions.ts b/src/features/vcs/logOptions.ts
index 4e594a831..835b4a096 100644
--- a/src/features/vcs/logOptions.ts
+++ b/src/features/vcs/logOptions.ts
@@ -22,6 +22,8 @@ export interface LogOptions {
   showDate: boolean;
   showHash: boolean;
   showSignature: boolean;
+  /** The row naming the columns, where they are resized and reordered. */
+  showColumnHeaders: boolean;
   highlightMine: boolean;
   highlightMerges: boolean;
   highlightCurrentBranch: boolean;
@@ -56,6 +58,7 @@ export const DEFAULT_LOG_OPTIONS: LogOptions = {
   showDate: true,
   showHash: false,
   showSignature: false,
+  showColumnHeaders: false,
   highlightMine: true,
   highlightMerges: true,
   highlightCurrentBranch: true,
diff --git a/src/features/vcs/logPresentation.ts b/src/features/vcs/logPresentation.ts
index c4471c990..77500a369 100644
--- a/src/features/vcs/logPresentation.ts
+++ b/src/features/vcs/logPresentation.ts
@@ -1,4 +1,11 @@
-import { collapseLinear, computeGraph, hideLongEdges, linearizeMerges, straightenLaneChanges } from "./graph";
+import {
+  collapseLinear,
+  compactLanes,
+  computeGraph,
+  hideLongEdges,
+  linearizeMerges,
+  straightenLaneChanges,
+} from "./graph";
 import { commitKey, graphCommit, type RepoCommit } from "./multiRoot";
 import type { LogOptions } from "./logOptions";
 
@@ -26,6 +33,6 @@ export function presentLogGraph(
   const byId = new Map(all.map((c) => [commitKey(c), c]));
   const commits = graph.map((c) => byId.get(c.id)!);
   const laid = computeGraph(graph).rows;
-  const rows = straightenLaneChanges(options.longEdges ? laid : hideLongEdges(laid));
+  const rows = straightenLaneChanges(compactLanes(options.longEdges ? laid : hideLongEdges(laid)));
   return { commits, graph, rows, linear, collapsed };
 }
diff --git a/src/features/vcs/remoteUi.tsx b/src/features/vcs/remoteUi.tsx
index 63554591e..6bedffcd6 100644
--- a/src/features/vcs/remoteUi.tsx
+++ b/src/features/vcs/remoteUi.tsx
@@ -149,6 +149,9 @@ interface PushNode {
   children?: PushNode[];
 }
 
+// A long outgoing list scrolls inside the dialog instead of growing it to the screen (IDEA: 800×450 centre panel).
+const PUSH_DIALOG_MAX_HEIGHT = 720;
+
 function MultiPushDialog({ onClose }: { onClose: () => void }) {
   const roots = useVcs((s) => s.roots);
   const [repos, setRepos] = useState<RepoPush[] | null>(null);
@@ -228,6 +231,8 @@ function MultiPushDialog({ onClose }: { onClose: () => void }) {
       title="Push Commits"
       onClose={onClose}
       width={repos?.some((r) => r.commits.length) ? 860 : 620}
+      maxHeight={PUSH_DIALOG_MAX_HEIGHT}
+      className={styles.pushDialog}
       resizable="both"
       footerStart={
         <>
@@ -441,6 +446,8 @@ function PushDialog({ target: pushTarget, onClose }: { target: PushTarget; onClo
       title={head ? tx`Push Commits to ${upstream ?? "remote"}` : "Push"}
       onClose={onClose}
       width={commits?.length ? 860 : 620}
+      maxHeight={PUSH_DIALOG_MAX_HEIGHT}
+      className={styles.pushDialog}
       resizable="both"
       footerStart={
         <>
diff --git a/src/features/vcs/worktrees.test.ts b/src/features/vcs/worktrees.test.ts
new file mode 100644
index 000000000..61ea6e477
--- /dev/null
+++ b/src/features/vcs/worktrees.test.ts
@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+import { isCurrentWorktree } from "./worktrees";
+
+describe("isCurrentWorktree", () => {
+  it("matches the repository root this window works in", () => {
+    expect(isCurrentWorktree("/work/app", "/work/app")).toBe(true);
+    expect(isCurrentWorktree("/work/app-wt", "/work/app")).toBe(false);
+    expect(isCurrentWorktree("/work/app/", "/work/app")).toBe(true);
+    expect(isCurrentWorktree("/work/app", null)).toBe(false);
+  });
+
+  it("ignores the drive letter's case and separators on Windows", () => {
+    expect(isCurrentWorktree("c:/Work/app", "C:/Work/app")).toBe(true);
+    expect(isCurrentWorktree("C:\\Work\\app", "C:/Work/app")).toBe(true);
+    // Only drive paths: elsewhere the case is part of the name.
+    expect(isCurrentWorktree("/Work/App", "/work/app")).toBe(false);
+  });
+});
diff --git a/src/features/vcs/worktrees.ts b/src/features/vcs/worktrees.ts
new file mode 100644
index 000000000..24139c026
--- /dev/null
+++ b/src/features/vcs/worktrees.ts
@@ -0,0 +1,13 @@
+/**
+ * Whether worktree `path` (as `git worktree list` prints it) is the repository root `root`
+ * this window works in. Git prints `C:/…` with the drive in either case, so drive paths
+ * compare case-insensitively; a trailing slash doesn't count.
+ */
+export function isCurrentWorktree(path: string, root: string | null | undefined): boolean {
+  if (!root) return false;
+  const norm = (p: string) => {
+    const s = p.replace(/\\/g, "/").replace(/(.)\/+$/, "$1");
+    return /^[A-Za-z]:\//.test(s) ? s.toLowerCase() : s;
+  };
+  return norm(path) === norm(root);
+}
diff --git a/src/features/welcome/ProjectsPage.tsx b/src/features/welcome/ProjectsPage.tsx
index a5c218793..10d4ea357 100644
--- a/src/features/welcome/ProjectsPage.tsx
+++ b/src/features/welcome/ProjectsPage.tsx
@@ -19,8 +19,9 @@ import {
   showContextMenu,
   T,
 } from "@/ui";
-import { askRemoveRecent, ProjectBadge, recentMenu } from "./RecentList";
-import { filterRecent, openRecent, useRecent, type RecentMatch } from "./recent";
+import { askRemoveRecent, groupMenu, ProjectBadge, recentMenu } from "./RecentList";
+import { openRecent, recentRows, setGroupExpanded, useRecent, type RecentMatch, type RecentRow } from "./recent";
+import type { RecentProjectGroup } from "@/platform/ipc";
 import styles from "./Welcome.module.css";
 import { tx } from "@/platform/i18n";
 
@@ -113,16 +114,78 @@ function Landing() {
   );
 }
 
+/** A project group: click or Enter folds it, its menu renames or removes it. */
+function GroupRow({
+  group,
+  count,
+  id,
+  selected,
+  onSelect,
+}: {
+  group: RecentProjectGroup;
+  count: number;
+  id: string;
+  selected: boolean;
+  onSelect: () => void;
+}) {
+  const ref = useRef<HTMLDivElement>(null);
+  useEffect(() => {
+    if (selected) ref.current?.scrollIntoView?.({ block: "nearest" });
+  }, [selected]);
+  return (
+    <div
+      ref={ref}
+      id={id}
+      role="option"
+      aria-selected={selected}
+      aria-expanded={group.expanded}
+      className={clsx(styles.project, styles.group, selected && styles.projectSelected)}
+      onMouseDown={(e) => e.preventDefault()}
+      onClick={() => {
+        onSelect();
+        void setGroupExpanded(group.name, !group.expanded);
+      }}
+      onContextMenu={(e) => {
+        e.preventDefault();
+        onSelect();
+        showContextMenu(e, groupMenu(group));
+      }}
+    >
+      <Icon name={group.expanded ? "chevron-down" : "chevron-right"} size={16} />
+      <Icon name="folder" size={16} />
+      <span className={styles.groupName}>{group.name}</span>
+      <span className={styles.groupCount}>{count}</span>
+      <IconButton
+        icon="more"
+        title="Group actions"
+        aria-haspopup="menu"
+        iconSize={16}
+        className={styles.projectMore}
+        tabIndex={-1}
+        onClick={(e) => {
+          e.stopPropagation();
+          onSelect();
+          const r = e.currentTarget.getBoundingClientRect();
+          showContextMenu({ x: r.left, y: r.bottom + 2 }, groupMenu(group));
+        }}
+      />
+    </div>
+  );
+}
+
 function ProjectRow({
   m,
   id,
   selected,
+  nested,
   onSelect,
   onOpen,
 }: {
   m: RecentMatch;
   id: string;
   selected: boolean;
+  /** Listed under a group. */
+  nested?: boolean;
   onSelect: () => void;
   onOpen: () => void;
 }) {
@@ -143,7 +206,7 @@ function ProjectRow({
       role="option"
       aria-selected={selected}
       title={m.project.path}
-      className={clsx(styles.project, selected && styles.projectSelected)}
+      className={clsx(styles.project, nested && styles.projectNested, selected && styles.projectSelected)}
       onMouseDown={(e) => e.preventDefault()}
       onClick={() => {
         onSelect();
@@ -195,10 +258,10 @@ function ProjectRow({
 }
 
 /** Keys shared by the search field and the list. Returns true when handled. */
-export function handleListKey(
+export function handleListKey<T>(
   e: Pick<KeyboardEvent, "key" | "metaKey" | "shiftKey">,
-  ctx: { items: readonly RecentMatch[]; current: number; caretAtEnd: boolean },
-): { kind: "move"; index: number } | { kind: "open" | "remove" | "menu"; match: RecentMatch } | null {
+  ctx: { items: readonly T[]; current: number; caretAtEnd: boolean },
+): { kind: "move"; index: number } | { kind: "open" | "remove" | "menu"; match: T } | null {
   const m = ctx.items[ctx.current];
   if (e.key === "Enter") return m ? { kind: "open", match: m } : null;
   if (m && ((e.key === "Delete" && ctx.caretAtEnd) || (e.key === "Backspace" && e.metaKey)))
@@ -210,13 +273,14 @@ export function handleListKey(
 
 export function ProjectsPage() {
   const projects = useRecent((s) => s.projects);
+  const groups = useRecent((s) => s.groups);
   const loaded = useRecent((s) => s.loaded);
   const home = useRecent((s) => s.home);
   const [query, setQuery] = useState("");
   const [active, setActive] = useState(0);
   const search = useRef<HTMLInputElement>(null);
   const baseId = useId();
-  const items = useMemo(() => filterRecent(projects, query, home), [projects, query, home]);
+  const items = useMemo(() => recentRows(projects, groups, query, home), [projects, groups, query, home]);
   const current = Math.max(0, Math.min(active, items.length - 1));
 
   if (!loaded) return null;
@@ -228,6 +292,13 @@ export function ProjectsPage() {
     const input = e.target instanceof HTMLInputElement ? e.target : null;
     const caretAtEnd =
       !input || (input.selectionStart === input.value.length && input.selectionEnd === input.value.length);
+    const row = items[current];
+    // A group folds with ← / → (and Enter, below), like a tree node.
+    if (row?.kind === "group" && !input && (e.key === "ArrowLeft" || e.key === "ArrowRight")) {
+      e.preventDefault();
+      void setGroupExpanded(row.group.name, e.key === "ArrowRight");
+      return;
+    }
     const r = handleListKey(e, { items, current, caretAtEnd });
     if (!r) {
       // Typing in the list goes to the search field.
@@ -240,12 +311,24 @@ export function ProjectsPage() {
       return;
     }
     e.preventDefault();
-    if (r.kind === "move") setActive(r.index);
-    else if (r.kind === "open") void openRecent(r.match.project);
-    else if (r.kind === "remove") void askRemoveRecent(r.match.project);
+    if (r.kind === "move") {
+      setActive(r.index);
+      return;
+    }
+    const match: RecentRow = r.match;
+    if (match.kind === "group") {
+      if (r.kind === "open") void setGroupExpanded(match.group.name, !match.group.expanded);
+      else if (r.kind === "menu") {
+        const el = document.getElementById(optionId(current))?.getBoundingClientRect();
+        showContextMenu({ x: (el?.right ?? 0) - 40, y: (el?.top ?? 0) + 24 }, groupMenu(match.group));
+      }
+      return;
+    }
+    if (r.kind === "open") void openRecent(match.m.project);
+    else if (r.kind === "remove") void askRemoveRecent(match.m.project);
     else {
       const el = document.getElementById(optionId(current))?.getBoundingClientRect();
-      showContextMenu({ x: (el?.right ?? 0) - 40, y: (el?.top ?? 0) + 24 }, recentMenu(r.match.project));
+      showContextMenu({ x: (el?.right ?? 0) - 40, y: (el?.top ?? 0) + 24 }, recentMenu(match.m.project));
     }
   };
 
@@ -279,16 +362,28 @@ export function ProjectsPage() {
         className={styles.projectList}
         onKeyDown={onKeyDown}
       >
-        {items.map((m, i) => (
-          <ProjectRow
-            key={m.project.path}
-            m={m}
-            id={optionId(i)}
-            selected={i === current}
-            onSelect={() => setActive(i)}
-            onOpen={() => void openRecent(m.project)}
-          />
-        ))}
+        {items.map((row, i) =>
+          row.kind === "group" ? (
+            <GroupRow
+              key={`group:${row.group.name}`}
+              group={row.group}
+              count={row.count}
+              id={optionId(i)}
+              selected={i === current}
+              onSelect={() => setActive(i)}
+            />
+          ) : (
+            <ProjectRow
+              key={row.m.project.path}
+              m={row.m}
+              id={optionId(i)}
+              selected={i === current}
+              nested={row.group !== null}
+              onSelect={() => setActive(i)}
+              onOpen={() => void openRecent(row.m.project)}
+            />
+          ),
+        )}
         {items.length === 0 && (
           <div className={styles.noMatches}>
             <T>No matching projects</T>
diff --git a/src/features/welcome/RecentList.tsx b/src/features/welcome/RecentList.tsx
index 4daccc5b9..bcb96ed3f 100644
--- a/src/features/welcome/RecentList.tsx
+++ b/src/features/welcome/RecentList.tsx
@@ -1,6 +1,6 @@
 import { useMemo, useState, type KeyboardEvent, type MouseEvent, type ReactNode } from "react";
 import clsx from "clsx";
-import { call, commands, type RecentProject } from "@/platform/ipc";
+import { call, commands, type RecentProject, type RecentProjectGroup } from "@/platform/ipc";
 import { parseRemoteLocation } from "@/platform/remote";
 import {
   HighlightedText,
@@ -13,9 +13,22 @@ import {
   showContextMenu,
   type MenuItem,
 } from "@/ui";
+import { promptInput } from "@/workbench/inputDialogs";
 import { confirm } from "@/workbench/messages";
 import { projectColorVars, projectInitials } from "@/workbench/projectColor";
-import { filterRecent, openRecent, removeRecent, useRecent, type RecentMatch } from "./recent";
+import {
+  createGroup,
+  filterRecent,
+  groupNameError,
+  groupOf,
+  moveToGroup,
+  openRecent,
+  removeGroup,
+  removeRecent,
+  renameGroup,
+  useRecent,
+  type RecentMatch,
+} from "./recent";
 import styles from "./Welcome.module.css";
 import { tx } from "@/platform/i18n";
 
@@ -38,6 +51,63 @@ export function ProjectBadge({ name, className }: { name: string; className?: st
   );
 }
 
+/** New Project Group…: asks for a name; with `path`, that project moves into the new group. */
+export async function askNewGroup(path?: string) {
+  const name = await promptInput({
+    title: "New Project Group",
+    label: "Group name:",
+    okLabel: "Create",
+    validate: (v) => groupNameError(v),
+  });
+  if (name !== null) await createGroup(name, path);
+}
+
+/** Move to Group: the other groups, a new one, or out of its group. */
+function moveToGroupMenu(project: RecentProject): MenuItem {
+  const groups = useRecent.getState().groups;
+  const current = groupOf(project.path, groups)?.name ?? null;
+  const others = groups.filter((g) => g.name !== current);
+  const submenu: MenuItem[] = [
+    ...others.map((g): MenuItem => ({
+      label: g.name,
+      verbatim: true,
+      run: () => void moveToGroup(project.path, g.name),
+    })),
+    ...(others.length ? [{ kind: "separator" } as const] : []),
+    { label: "New Group…", run: () => void askNewGroup(project.path) },
+    ...(current
+      ? [{ label: tx`Remove from '${current}'`, verbatim: true, run: () => void moveToGroup(project.path, null) }]
+      : []),
+  ];
+  return { label: "Move to Group", icon: "folder", submenu };
+}
+
+/** A project group's actions. */
+export function groupMenu(group: RecentProjectGroup): MenuItem[] {
+  return [
+    {
+      label: "Rename Group…",
+      icon: "edit",
+      run: () =>
+        void promptInput({
+          title: "Rename Project Group",
+          label: "Group name:",
+          initial: group.name,
+          okLabel: "Rename",
+          validate: (v) => groupNameError(v, group.name),
+        }).then((name) => (name === null ? undefined : renameGroup(group.name, name))),
+    },
+    { label: "New Project Group…", icon: "plus", run: () => void askNewGroup() },
+    { kind: "separator" },
+    {
+      label: "Remove Group",
+      icon: "close",
+      danger: true,
+      run: () => void removeGroup(group.name),
+    },
+  ];
+}
+
 export function recentMenu(project: RecentProject, onOpened?: () => void): MenuItem[] {
   // A remote project has no local folder.
   const remote = parseRemoteLocation(project.path);
@@ -54,7 +124,7 @@ export function recentMenu(project: RecentProject, onOpened?: () => void): MenuI
           label: "Open in New Window",
           icon: "folder-open",
           run: () =>
-            void call(commands.windowOpenRemote(remote.sshConfig, remote.path, true))
+            void call(commands.windowOpenRemote(remote.target, remote.path, true))
               .then(() => onOpened?.())
               .catch(() => undefined),
         }
@@ -73,6 +143,8 @@ export function recentMenu(project: RecentProject, onOpened?: () => void): MenuI
       run: () => void navigator.clipboard?.writeText(project.path).catch(() => undefined),
     },
     { kind: "separator" },
+    // Groups hold local projects (remote ones live in this window's own list).
+    ...(remote ? [] : [moveToGroupMenu(project), { kind: "separator" } as const]),
     {
       id: "remove",
       label: "Remove from Recent Projects…",
diff --git a/src/features/welcome/Welcome.module.css b/src/features/welcome/Welcome.module.css
index da2a3032e..a97c47ae0 100644
--- a/src/features/welcome/Welcome.module.css
+++ b/src/features/welcome/Welcome.module.css
@@ -172,6 +172,26 @@
 .projectBadge {
   margin-top: 1px;
 }
+/* A project group: one line, folds its projects. */
+.group {
+  align-items: center;
+  gap: 6px;
+  --icon-color: var(--fg-muted);
+}
+.groupName {
+  flex: 1;
+  min-width: 0;
+  color: var(--fg-strong);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.groupCount {
+  color: var(--fg-faint);
+}
+.projectNested {
+  padding-left: 32px;
+}
 .projectText {
   flex: 1;
   min-width: 0;
diff --git a/src/features/welcome/openRecent.test.ts b/src/features/welcome/openRecent.test.ts
new file mode 100644
index 000000000..8c23d5cdc
--- /dev/null
+++ b/src/features/welcome/openRecent.test.ts
@@ -0,0 +1,52 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const openProject = vi.fn();
+const openRemoteProject = vi.fn();
+const UNC = String.raw`\\wsl.localhost\Ubuntu\home\me\app`;
+
+vi.mock("@/platform/ipc", async (orig) => {
+  const real = await orig<typeof import("@/platform/ipc")>();
+  return {
+    ...real,
+    isTauri: () => true,
+    commands: {
+      ...real.commands,
+      wslResolve: async (p: string) =>
+        p === UNC ? { target: { kind: "wsl", distro: "Ubuntu" }, path: "/home/me/app" } : null,
+    },
+  };
+});
+vi.mock("@/platform/project", async (orig) => {
+  const real = await orig<typeof import("@/platform/project")>();
+  return { ...real, openProject: (p: string) => openProject(p) };
+});
+vi.mock("@/workbench/projectWindow", () => ({
+  openRemoteProject: (...a: unknown[]) => openRemoteProject(...a),
+}));
+
+const { openRecent } = await import("./recent");
+const { useProject } = await import("@/platform/project");
+
+beforeEach(() => {
+  openProject.mockReset();
+  openRemoteProject.mockReset().mockResolvedValue(true);
+  useProject.setState({ project: null, lightEdit: false });
+});
+
+describe("openRecent", () => {
+  it("opens a legacy WSL UNC recent through the distro, not as a local folder", async () => {
+    expect(await openRecent({ path: UNC, name: "app" })).toBe(true);
+    expect(openRemoteProject).toHaveBeenCalledWith(
+      { kind: "wsl", distro: "Ubuntu" },
+      "/home/me/app",
+      expect.any(Function),
+    );
+    expect(openProject).not.toHaveBeenCalled();
+  });
+
+  it("still opens a plain local recent locally", async () => {
+    await openRecent({ path: "/p/local", name: "local" });
+    expect(openProject).toHaveBeenCalledWith("/p/local");
+    expect(openRemoteProject).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/features/welcome/recent.test.ts b/src/features/welcome/recent.test.ts
index 4534d688e..322e9c83e 100644
--- a/src/features/welcome/recent.test.ts
+++ b/src/features/welcome/recent.test.ts
@@ -1,7 +1,17 @@
 import { afterEach, describe, expect, it } from "vitest";
 import type { RecentProject } from "@/bindings";
 import { useProject } from "@/platform/project";
-import { filterRecent, tildify } from "./recent";
+import {
+  createGroup,
+  filterRecent,
+  groupNameError,
+  moveToGroup,
+  recentRows,
+  removeGroup,
+  renameGroup,
+  tildify,
+  useRecent,
+} from "./recent";
 import { lastSessionProject, reopenEnabled, trackSession } from "./session";
 
 const p = (name: string, path: string, branch: string | null = null): RecentProject => ({
@@ -77,3 +87,45 @@ describe("session restore", () => {
     stop();
   });
 });
+
+describe("project groups", () => {
+  const rows = (query = "") =>
+    recentRows(projects, useRecent.getState().groups, query, "/Users/me").map((r) =>
+      r.kind === "group" ? `[${r.group.name} ${r.count}]` : `${r.group ? "  " : ""}${r.m.project.name}`,
+    );
+  afterEach(() => useRecent.setState({ groups: [] }));
+
+  it("lists groups first with their projects, then the rest; a search lists matches only", async () => {
+    expect(rows()).toEqual(["acme-api", "openidea-ide", "tokio", "notes"]);
+    await createGroup(" Work ", "/Users/me/dev/acme");
+    await moveToGroup("/Users/me/dev/openidea", "Work");
+    await createGroup("Oss", "/Users/me/oss/tokio");
+    expect(rows()).toEqual(["[Work 2]", "  acme-api", "  openidea-ide", "[Oss 1]", "  tokio", "notes"]);
+    expect(rows("tok")).toEqual(["tokio"]);
+
+    useRecent.setState((s) => ({ groups: s.groups.map((g) => ({ ...g, expanded: g.name !== "Work" })) }));
+    expect(rows()).toEqual(["[Work 2]", "[Oss 1]", "  tokio", "notes"]);
+  });
+
+  it("moves a project between groups, renames and removes groups without dropping projects", async () => {
+    await createGroup("Work", "/Users/me/dev/acme");
+    await createGroup("Oss");
+    expect(groupNameError("work ")).toBeNull();
+    expect(groupNameError(" Work")).toBe("A group named 'Work' already exists");
+    expect(groupNameError("Work", "Work")).toBeNull();
+    expect(groupNameError("  ")).toBe("Enter a group name");
+    // A second group of the same name is not created.
+    await createGroup("Work", "/Users/me/oss/tokio");
+    expect(useRecent.getState().groups.map((g) => g.name)).toEqual(["Work", "Oss"]);
+
+    await moveToGroup("/Users/me/dev/acme", "Oss");
+    expect(rows()).toEqual(["[Work 0]", "[Oss 1]", "  acme-api", "openidea-ide", "tokio", "notes"]);
+    await renameGroup("Oss", "Open source");
+    await moveToGroup("/Users/me/oss/tokio", "Open source");
+    await removeGroup("Work");
+    expect(rows()).toEqual(["[Open source 2]", "  acme-api", "  tokio", "openidea-ide", "notes"]);
+    await moveToGroup("/Users/me/dev/acme", null);
+    await removeGroup("Open source");
+    expect(rows()).toEqual(["acme-api", "openidea-ide", "tokio", "notes"]);
+  });
+});
diff --git a/src/features/welcome/recent.ts b/src/features/welcome/recent.ts
index 98cc4b4c9..701942b8b 100644
--- a/src/features/welcome/recent.ts
+++ b/src/features/welcome/recent.ts
@@ -1,9 +1,26 @@
 /** Recent projects: loading, filtering, opening and removal. */
 import { create } from "zustand";
 import { executeAction, getAction } from "@/platform/actions";
-import { commands, IpcError, isCancelled, isTauri, type RecentProject } from "@/platform/ipc";
+import {
+  commands,
+  IpcError,
+  isCancelled,
+  isTauri,
+  type RecentProject,
+  type RecentProjectGroup,
+  type RemoteTarget,
+} from "@/platform/ipc";
 import { openProject, useProject } from "@/platform/project";
-import { connectRemote, forgetRemote, parseRemoteLocation, recentRemotes, remoteLocation } from "@/platform/remote";
+import {
+  connectRemote,
+  forgetRemote,
+  parseRemoteLocation,
+  recentRemotes,
+  remoteLocation,
+  resolveRemoteLocation,
+  sameTarget,
+  targetName,
+} from "@/platform/remote";
 import { tx } from "@/platform/i18n";
 import { fuzzyMatch } from "@/ui";
 import { notifications } from "@/workbench/contributions";
@@ -11,6 +28,8 @@ import { openRemoteProject } from "@/workbench/projectWindow";
 
 interface RecentState {
   projects: RecentProject[];
+  /** Project groups (New Project Group…), shown above the ungrouped projects. */
+  groups: RecentProjectGroup[];
   loaded: boolean;
   home: string | null;
   version: string | null;
@@ -20,6 +39,7 @@ interface RecentState {
 
 export const useRecent = create<RecentState>(() => ({
   projects: [],
+  groups: [],
   loaded: false,
   home: null,
   version: null,
@@ -43,13 +63,15 @@ export async function loadRecent() {
     useRecent.setState({ projects: SAMPLE, loaded: true, home: "/Users/dev", version: "0.1.0-dev" });
     return;
   }
-  const [projects, info, home] = await Promise.all([
+  const [projects, groups, info, home] = await Promise.all([
     commands.recentProjects().catch(() => [] as RecentProject[]),
+    commands.recentProjectGroups().catch(() => [] as RecentProjectGroup[]),
     commands.appInfo().catch(() => null),
     import("@tauri-apps/api/path").then((m) => m.homeDir()).catch(() => null),
   ]);
   useRecent.setState({
     projects: withRemotes(projects),
+    groups,
     loaded: true,
     version: info?.version ?? useRecent.getState().version,
     home: home ? home.replace(/\/+$/, "") : useRecent.getState().home,
@@ -59,7 +81,7 @@ export async function loadRecent() {
 /** The recent remote projects (Remote Development) among the local ones, most recent first. */
 function withRemotes(local: RecentProject[]): RecentProject[] {
   const remote: RecentProject[] = recentRemotes().map((r) => ({
-    path: remoteLocation(r.sshConfig, r.path),
+    path: remoteLocation(r.target, r.path),
     name: r.name,
     openedAtMs: r.openedAtMs,
     branch: null,
@@ -72,15 +94,19 @@ function withRemotes(local: RecentProject[]): RecentProject[] {
 export function remoteDisplay(location: string): string | null {
   const r = parseRemoteLocation(location);
   if (!r) return null;
-  const host = recentRemotes().find((x) => x.sshConfig === r.sshConfig && x.path === r.path)?.host || r.sshConfig;
+  const host =
+    recentRemotes().find((x) => sameTarget(x.target, r.target) && x.path === r.path)?.host || targetName(r.target);
   return `${host}:${r.path}`;
 }
 
 export async function removeRecent(path: string) {
-  useRecent.setState((s) => ({ projects: s.projects.filter((p) => p.path !== path) }));
+  useRecent.setState((s) => ({
+    projects: s.projects.filter((p) => p.path !== path),
+    groups: s.groups.map((g) => (g.paths.includes(path) ? { ...g, paths: g.paths.filter((p) => p !== path) } : g)),
+  }));
   const remote = parseRemoteLocation(path);
   if (remote) {
-    forgetRemote(remote.sshConfig, remote.path);
+    forgetRemote(remote.target, remote.path);
     return;
   }
   if (!isTauri()) return;
@@ -99,7 +125,7 @@ export async function openRecent(project: Pick<RecentProject, "path" | "name">):
     });
     return false;
   }
-  const remote = parseRemoteLocation(project.path);
+  const remote = await resolveRemoteLocation(project.path);
   if (remote) return openRemote(project, remote);
   const current = useProject.getState().project;
   if (current?.root === project.path) return true;
@@ -131,12 +157,12 @@ export async function openRecent(project: Pick<RecentProject, "path" | "name">):
 
 async function openRemote(
   project: Pick<RecentProject, "path" | "name">,
-  remote: { sshConfig: string; path: string },
+  remote: { target: RemoteTarget; path: string },
 ): Promise<boolean> {
   try {
-    return await openRemoteProject(remote.sshConfig, remote.path, async () => {
+    return await openRemoteProject(remote.target, remote.path, async () => {
       useRecent.setState({ opening: project.path });
-      await connectRemote(remote.sshConfig, remote.path);
+      await connectRemote(remote.target, remote.path);
     });
   } catch (e) {
     if (isCancelled(e)) return false;
@@ -205,3 +231,90 @@ function isCompactMatch(indices: number[]): boolean {
   if (indices.length < 2) return true;
   return indices[indices.length - 1]! - indices[0]! < indices.length * 6;
 }
+
+// ---------------------------------------------------------------------------
+// Project groups
+
+/** The group `path` belongs to, if any. */
+export function groupOf(path: string, groups: readonly RecentProjectGroup[]): RecentProjectGroup | undefined {
+  return groups.find((g) => g.paths.includes(path));
+}
+
+/** Saves `next` (shown at once; the backend's normalised copy replaces it). */
+async function saveGroups(next: RecentProjectGroup[]) {
+  useRecent.setState({ groups: next });
+  if (!isTauri()) return;
+  const r = await commands.setRecentProjectGroups(next);
+  if (r.status === "ok") useRecent.setState({ groups: r.data });
+  else notifications().notify({ level: "error", title: "Cannot save project groups", body: r.error.message });
+}
+
+const groups = () => useRecent.getState().groups;
+
+/** Why `name` can't name a new group (or group `current` renamed), or null. */
+export function groupNameError(value: string, current?: string): string | null {
+  const name = value.trim();
+  if (!name) return tx("Enter a group name");
+  return name !== current && groups().some((g) => g.name === name) ? tx`A group named '${name}' already exists` : null;
+}
+
+/** New Project Group…; with `path`, the project moves into it. */
+export function createGroup(name: string, path?: string) {
+  const n = name.trim();
+  if (groupNameError(n)) return Promise.resolve();
+  const rest = groups().map((g) => (path ? { ...g, paths: g.paths.filter((p) => p !== path) } : g));
+  return saveGroups([...rest, { name: n, paths: path ? [path] : [], expanded: true }]);
+}
+
+export function renameGroup(name: string, to: string) {
+  const n = to.trim();
+  if (n === name || groupNameError(n, name)) return Promise.resolve();
+  return saveGroups(groups().map((g) => (g.name === name ? { ...g, name: n } : g)));
+}
+
+/** Removes the group; its projects stay in the list, ungrouped. */
+export function removeGroup(name: string) {
+  return saveGroups(groups().filter((g) => g.name !== name));
+}
+
+/** Moves `path` into group `name`, or out of every group with `null`. */
+export function moveToGroup(path: string, name: string | null) {
+  return saveGroups(
+    groups().map((g) => {
+      const paths = g.paths.filter((p) => p !== path);
+      return { ...g, paths: g.name === name ? [...paths, path] : paths };
+    }),
+  );
+}
+
+export function setGroupExpanded(name: string, expanded: boolean) {
+  return saveGroups(groups().map((g) => (g.name === name ? { ...g, expanded } : g)));
+}
+
+export type RecentRow =
+  | { kind: "group"; group: RecentProjectGroup; count: number }
+  | { kind: "project"; m: RecentMatch; group: string | null };
+
+/**
+ * The rows of the list: without a query, groups first (their projects under the expanded
+ * ones, most recent first), then the ungrouped projects; while searching, the matches only.
+ */
+export function recentRows(
+  projects: readonly RecentProject[],
+  groupList: readonly RecentProjectGroup[],
+  query: string,
+  home?: string | null,
+): RecentRow[] {
+  const matches = filterRecent(projects, query, home);
+  if (query.trim() || groupList.length === 0) return matches.map((m) => ({ kind: "project", m, group: null }));
+  const rows: RecentRow[] = [];
+  const grouped = new Set<string>();
+  for (const group of groupList) {
+    const members = matches.filter((m) => group.paths.includes(m.project.path));
+    members.forEach((m) => grouped.add(m.project.path));
+    rows.push({ kind: "group", group, count: members.length });
+    if (group.expanded) rows.push(...members.map((m): RecentRow => ({ kind: "project", m, group: group.name })));
+  }
+  for (const m of matches) if (!grouped.has(m.project.path)) rows.push({ kind: "project", m, group: null });
+  return rows;
+}
diff --git a/src/features/welcome/session.test.ts b/src/features/welcome/session.test.ts
index b18239a56..4e6ff43b7 100644
--- a/src/features/welcome/session.test.ts
+++ b/src/features/welcome/session.test.ts
@@ -1,15 +1,26 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
 const openProject = vi.fn();
+const connectRemote = vi.fn();
+const UNC = String.raw`\\wsl.localhost\Ubuntu\home\me\app`;
 
 vi.mock("@/platform/ipc", async (orig) => {
   const real = await orig<typeof import("@/platform/ipc")>();
   return {
     ...real,
     isTauri: () => true,
-    commands: { ...real.commands, settingsGet: async () => ({ general: { reopenLastProject: true } }) },
+    commands: {
+      ...real.commands,
+      settingsGet: async () => ({ general: { reopenLastProject: true } }),
+      wslResolve: async (p: string) =>
+        p === UNC ? { target: { kind: "wsl", distro: "Ubuntu" }, path: "/home/me/app" } : null,
+    },
   };
 });
+vi.mock("@/platform/remote", async (orig) => {
+  const real = await orig<typeof import("@/platform/remote")>();
+  return { ...real, connectRemote: (t: unknown, p: string) => connectRemote(t, p) };
+});
 vi.mock("@tauri-apps/api/window", () => ({ getCurrentWindow: () => ({ label: "main" }) }));
 vi.mock("@/platform/project", async (orig) => {
   const real = await orig<typeof import("@/platform/project")>();
@@ -21,6 +32,7 @@ const { provideStartupLaunch, useProject } = await import("@/platform/project");
 
 beforeEach(() => {
   openProject.mockReset();
+  connectRemote.mockReset();
   useProject.setState({ project: null, lightEdit: false });
   sessionStorage.clear();
   localStorage.setItem("openidea.session.openProject", "/p/last");
@@ -67,4 +79,12 @@ describe("reopenLastProject", () => {
     await reopenLastProject();
     expect(openProject).toHaveBeenCalledWith("/p/last");
   });
+
+  it("restores a session saved as a WSL UNC folder through the distro", async () => {
+    localStorage.setItem("openidea.session.openProject", UNC);
+    provideStartupLaunch(Promise.resolve());
+    await reopenLastProject();
+    expect(connectRemote).toHaveBeenCalledWith({ kind: "wsl", distro: "Ubuntu" }, "/home/me/app");
+    expect(openProject).not.toHaveBeenCalled();
+  });
 });
diff --git a/src/features/welcome/session.ts b/src/features/welcome/session.ts
index 2a6002c7a..0ea89cf75 100644
--- a/src/features/welcome/session.ts
+++ b/src/features/welcome/session.ts
@@ -7,7 +7,7 @@ import { getCurrentWindow } from "@tauri-apps/api/window";
 import { create } from "zustand";
 import { commands, isCancelled, isTauri, type Settings } from "@/platform/ipc";
 import { openProject, startupLaunchHandled, useProject } from "@/platform/project";
-import { connectRemote, parseRemoteLocation, projectLocation } from "@/platform/remote";
+import { connectRemote, projectLocation, resolveRemoteLocation } from "@/platform/remote";
 import { notifications } from "@/workbench/contributions";
 
 const SESSION_KEY = "openidea.session.openProject";
@@ -117,8 +117,8 @@ async function reopen(path: string) {
   const name = path.slice(path.lastIndexOf("/") + 1) || path;
   useSession.setState({ reopening: path });
   try {
-    const remote = parseRemoteLocation(path);
-    if (remote) await connectRemote(remote.sshConfig, remote.path);
+    const remote = await resolveRemoteLocation(path);
+    if (remote) await connectRemote(remote.target, remote.path);
     else await openProject(path);
   } catch (e) {
     write(SESSION_KEY, null);
diff --git a/src/main.tsx b/src/main.tsx
index 9b55abf3c..af66b639e 100644
--- a/src/main.tsx
+++ b/src/main.tsx
@@ -32,7 +32,10 @@ if (import.meta.env.DEV && isTauri()) {
 }
 
 installRepeatedDoubleClick();
-if (guessOs() === "macos") installReorderedTapClick();
+// WebKit only (bug 219670). In Chromium (the e2e browser) a scripted double-click stamps its
+// second press like the release before it, which the shim would take for a reordered tap and
+// click twice.
+if (guessOs() === "macos" && !/Chrome|Firefox/.test(navigator.userAgent)) installReorderedTapClick();
 installWindowDrag();
 installPointerFocus();
 installErrorLogging();
diff --git a/src/platform/__fixtures__/colorSchemes/monokai-php.icls b/src/platform/__fixtures__/colorSchemes/monokai-php.icls
new file mode 100644
index 000000000..03d90ddd7
--- /dev/null
+++ b/src/platform/__fixtures__/colorSchemes/monokai-php.icls
@@ -0,0 +1,24 @@
+<scheme name="Monokai PHP" version="142" parent_scheme="Default">
+  <attributes>
+    <option name="TEXT"><value><option name="FOREGROUND" value="f8f8f2"/><option name="BACKGROUND" value="0"/></value></option>
+    <option name="DEFAULT_IDENTIFIER"><value><option name="FOREGROUND" value="e162d1"/></value></option>
+    <option name="DEFAULT_KEYWORD"><value><option name="FOREGROUND" value="41abff"/><option name="FONT_TYPE" value="1"/></value></option>
+    <option name="JAVA_KEYWORD"><value><option name="FOREGROUND" value="f72671"/><option name="FONT_TYPE" value="1"/></value></option>
+    <option name="JAVA_STRING"><value><option name="FOREGROUND" value="ffe792"/><option name="FONT_TYPE" value="1"/></value></option>
+    <option name="PHP_CLASS"><value><option name="FOREGROUND" value="ae81ff"/></value></option>
+    <option name="PHP_COMMENT"><value><option name="FOREGROUND" value="75715e"/></value></option>
+    <option name="PHP_DOC_COMMENT_ID"><value><option name="FOREGROUND" value="75715e"/></value></option>
+    <option name="PHP_FUNCTION"><value><option name="FOREGROUND" value="8de12d"/></value></option>
+    <option name="PHP_FUNCTION_CALL"><value><option name="FOREGROUND" value="8de12d"/></value></option>
+    <option name="PHP_INSTANCE_FIELD"><value><option name="FOREGROUND" value="48d8ee"/><option name="FONT_TYPE" value="1"/></value></option>
+    <option name="PHP_KEYWORD"><value><option name="FOREGROUND" value="f92672"/></value></option>
+    <option name="PHP_NUMBER"><value><option name="FOREGROUND" value="ae81ff"/></value></option>
+    <option name="PHP_OPERATION_SIGN"><value><option name="FOREGROUND" value="f72671"/></value></option>
+    <option name="PHP_BRACKETS"><value><option name="FOREGROUND" value="ffffff"/></value></option>
+    <option name="PHP_COMMA"><value><option name="FOREGROUND" value="ffffff"/></value></option>
+    <option name="PHP_SEMICOLON"><value><option name="FOREGROUND" value="ffffff"/></value></option>
+    <option name="PHP_PARAMETER"><value><option name="FOREGROUND" value="48d8ee"/></value></option>
+    <option name="PHP_STRING"><value><option name="FOREGROUND" value="ffe792"/></value></option>
+    <option name="PHP_VAR"><value><option name="FOREGROUND" value="48d8ee"/></value></option>
+  </attributes>
+</scheme>
diff --git a/src/platform/colorScheme.ts b/src/platform/colorScheme.ts
index 93564613b..4e0dbc5ec 100644
--- a/src/platform/colorScheme.ts
+++ b/src/platform/colorScheme.ts
@@ -32,6 +32,8 @@ export interface AttributeDef {
   /** A semantic modifier whose only configurable attribute is italic. */
   italicOnly?: boolean;
   defaultItalic?: boolean;
+  /** CodeMirror language name; unset attributes are language defaults. */
+  language?: string;
 }
 
 const syn = (id: string, name: string, path: string[], token: string): AttributeDef => ({
@@ -45,7 +47,7 @@ const syn = (id: string, name: string, path: string[], token: string): Attribute
 const LD = "Language Defaults";
 
 /** IDEA-style attribute tree: General, Language Defaults, then languages. */
-export const ATTRIBUTES: readonly AttributeDef[] = [
+const BASE_ATTRIBUTES: readonly AttributeDef[] = [
   { id: "text", name: "Default text", path: ["General", "Text"], fg: "--fg-editor", bg: "--bg-editor" },
   { id: "caret", name: "Caret", path: ["General", "Editor"], fg: "--caret" },
   { id: "caretRow", name: "Caret row", path: ["General", "Editor"], bg: "--bg-current-line" },
@@ -152,6 +154,26 @@ export const ATTRIBUTES: readonly AttributeDef[] = [
   syn("regexp", "Regular expression", ["RegExp"], "regexp"),
 ];
 
+const SCHEME_LANGUAGES = { java: "Java", kotlin: "Kotlin", php: "PHP" } as const;
+
+export const ATTRIBUTES: readonly AttributeDef[] = [
+  ...BASE_ATTRIBUTES,
+  ...Object.entries(SCHEME_LANGUAGES).flatMap(([id, language]) =>
+    BASE_ATTRIBUTES.filter((a) => a.path[0] === LD && !/^(semantic|bracket)\d$/.test(a.id)).map((a) => ({
+      ...a,
+      id: `${id}.${a.id}`,
+      path: [language, ...a.path.slice(1)],
+      language,
+    })),
+  ),
+  ...[
+    ["brackets", "Brackets", "bracket"],
+    ["separator", "Comma and semicolon", "separator"],
+    ["scriptTag", "PHP tags", "processing-instruction"],
+    ["staticField", "Static field", "static-property"],
+  ].map(([id, name, token]) => ({ ...syn(`php.${id}`, name!, ["PHP"], token!), language: "PHP" })),
+];
+
 // --- scheme base values ------------------------------------------------------
 
 /** Variables a scheme sets: every attribute variable plus the editor tokens derived from them. */
@@ -304,10 +326,12 @@ const EFFECT_CSS: Record<string, (c: string) => string> = {
 /** Declarations for the overrides of one scheme. */
 export function overrideDeclarations(
   overrides: Record<string, TextAttributesOverride> | undefined,
+  language?: string,
 ): Array<[string, string]> {
   const out: Array<[string, string]> = [];
   if (!overrides) return out;
   for (const attr of ATTRIBUTES) {
+    if (attr.language !== language) continue;
     const o = overrides[attr.id];
     if (!o) continue;
     if (isHexColor(o.foreground) && attr.fg) out.push([attr.fg, o.foreground]);
@@ -402,5 +426,15 @@ export function schemeCss(
   const body = decls
     .filter(([k, v]) => /^--[\w-]+$/.test(k) && SAFE.test(v))
     .map(([k, v]) => `  ${k}: ${v} !important;`);
-  return body.length ? `:root {\n${body.join("\n")}\n}\n` : "";
+  let css = body.length ? `:root {\n${body.join("\n")}\n}\n` : "";
+  for (const language of Object.values(SCHEME_LANGUAGES)) {
+    const languageBody = [
+      ...overrideDeclarations(valid[id]?.attributes, language),
+      ...overrideDeclarations(overrides?.[id], language),
+    ]
+      .filter(([k, v]) => /^--[\w-]+$/.test(k) && SAFE.test(v))
+      .map(([k, v]) => `  ${k}: ${v} !important;`);
+    if (languageBody.length) css += `.cm-editor[data-language="${language}"] {\n${languageBody.join("\n")}\n}\n`;
+  }
+  return css;
 }
diff --git a/src/platform/i18n.test.ts b/src/platform/i18n.test.ts
index c66e8cf44..4a6e565ca 100644
--- a/src/platform/i18n.test.ts
+++ b/src/platform/i18n.test.ts
@@ -248,7 +248,7 @@ describe("catalogs", () => {
   it("exist for exactly the supported locales", () => {
     expect(translated.length).toBeGreaterThan(0);
     expect(Object.keys(translations).sort()).toEqual(translated);
-    expect(Object.keys(texts).sort()).toEqual(translated);
+    expect(Object.keys(texts).sort()).toEqual([...SUPPORTED_LOCALES].sort());
   });
 
   it("translate source text into non-empty text", () => {
diff --git a/src/platform/icls.test.ts b/src/platform/icls.test.ts
index 9e914a56b..4f72ec1d7 100644
--- a/src/platform/icls.test.ts
+++ b/src/platform/icls.test.ts
@@ -12,12 +12,48 @@ const fixture = (name: string) => readFileSync(`src/platform/__fixtures__/colorS
 beforeAll(() => _setSchemeSource(readFileSync("src/styles/tokens.css", "utf8")));
 
 describe(".icls schemes", () => {
+  it("resolves explicit attribute inheritance independent of XML order and stops cycles", () => {
+    const { scheme } = parseIcls(`<scheme name="Inherited"><attributes>
+      <option name="PHP_PARAMETER" baseAttributes="PHP_VAR"/>
+      <option name="PHP_VAR" baseAttributes="DEFAULT_IDENTIFIER"/>
+      <option name="DEFAULT_IDENTIFIER"><value><option name="FOREGROUND" value="48d8ee"/></value></option>
+      <option name="PHP_STRING" baseAttributes="PHP_NUMBER"/>
+      <option name="PHP_NUMBER" baseAttributes="PHP_STRING"/>
+      </attributes></scheme>`);
+    expect(scheme.attributes["php.parameter"]).toEqual({ foreground: "#48d8ee", bold: false, italic: false });
+    expect(scheme.attributes["php.identifier"]).toEqual(scheme.attributes["php.parameter"]);
+    expect(scheme.attributes["php.string"]).toBeUndefined();
+  });
+
+  it("preserves PHP colours and regular styles separately from Java and language defaults", () => {
+    const { scheme } = parseIcls(fixture("monokai-php"));
+    expect(scheme.parent).toBe("dark");
+    expect(scheme.attributes["php.identifier"]).toEqual({ foreground: "#48d8ee", bold: false, italic: false });
+    expect(scheme.attributes["php.keyword"]).toEqual({ foreground: "#f92672", bold: false, italic: false });
+    expect(scheme.attributes["php.string"]).toEqual({ foreground: "#ffe792", bold: false, italic: false });
+    expect(scheme.attributes["php.docComment"]).toEqual({ foreground: "#75715e", bold: false, italic: false });
+    expect(scheme.attributes["java.string"]).toEqual({ foreground: "#ffe792", bold: true, italic: false });
+    expect(scheme.attributes.keyword?.foreground).toBe("#41abff");
+    const customs = { "custom-php": scheme };
+    const css = schemeCss("custom-php", undefined, null, customs);
+    expect(css).toContain('.cm-editor[data-language="PHP"]');
+    expect(css).toContain("--syn-variable: #48d8ee !important");
+    const roundTrip = parseIcls(exportIcls("custom-php", customs)).scheme;
+    expect(roundTrip.attributes["php.string"]).toEqual(scheme.attributes["php.string"]);
+    expect(roundTrip.attributes["java.string"]).toEqual(scheme.attributes["java.string"]);
+  });
+
   it("maps defaults, Java/Kotlin, editor surfaces, search and diagnostics with counts", () => {
     const { scheme, applied, skipped } = parseIcls(fixture("forest"));
     expect(scheme.name).toBe("Forest & Moss");
     expect(scheme.parent).toBe("dark");
-    expect(scheme.attributes.keyword).toEqual({ foreground: "#99dd77", bold: true, italic: false });
-    expect(scheme.attributes.functionDeclaration).toEqual({ foreground: "#e0c080", bold: false, italic: true });
+    expect(scheme.attributes.keyword).toEqual({ foreground: "#aadd88", bold: false, italic: false });
+    expect(scheme.attributes["java.keyword"]).toEqual({ foreground: "#99dd77", bold: true, italic: false });
+    expect(scheme.attributes["kotlin.functionDeclaration"]).toEqual({
+      foreground: "#e0c080",
+      bold: false,
+      italic: true,
+    });
     expect(scheme.attributes.text).toEqual({ foreground: "#d8ebd8", background: "#18281e" });
     expect(scheme.attributes.caret?.foreground).toBe("#f0e080");
     expect(scheme.attributes.selection?.background).toBe("#406040");
@@ -53,8 +89,8 @@ describe(".icls schemes", () => {
   });
 
   it.each([
-    ["Darcula", "ffffff", "dark"],
-    ["Default", "000000", "light"],
+    ["Darcula", "ffffff", "light"],
+    ["Default", "000000", "dark"],
     ["Other", "101820", "dark"],
     ["Other", "fefefe", "light"],
     ["", "0", "dark"],
@@ -111,7 +147,8 @@ describe(".icls schemes", () => {
       root.dataset.theme = theme;
       const css = schemeCss(id, overrides, root, customs);
       expect(css).toContain("--bg-editor: #18281e !important");
-      expect(css.lastIndexOf("--syn-keyword: #abcdef")).toBeGreaterThan(css.indexOf("--syn-keyword: #99dd77"));
+      expect(css.indexOf("--syn-keyword: #abcdef")).toBeGreaterThan(css.indexOf("--syn-keyword: #aadd88"));
+      expect(css).toContain('.cm-editor[data-language="Java"]');
       expect(effectiveScheme("theme-default", root, customs)).toBe(theme);
       const deleted = deleteScheme(customs, overrides, id, id);
       expect(deleted).toEqual({ customs: {}, overrides: {}, selected: "theme-default" });
diff --git a/src/platform/icls.ts b/src/platform/icls.ts
index 7062162ee..1e17f8ba6 100644
--- a/src/platform/icls.ts
+++ b/src/platform/icls.ts
@@ -96,17 +96,40 @@ const LANGUAGE_KEYS: Record<string, string> = {
   PARENTHS: "operator",
 };
 for (const [name, id] of Object.entries(LANGUAGE_KEYS)) {
-  ATTRIBUTE_NAMES[`JAVA_${name}`] = id;
-  ATTRIBUTE_NAMES[`KOTLIN_${name}`] = id;
+  ATTRIBUTE_NAMES[`JAVA_${name}`] = `java.${id}`;
+  ATTRIBUTE_NAMES[`KOTLIN_${name}`] = `kotlin.${id}`;
   ATTRIBUTE_NAMES[name] = id;
 }
 Object.assign(ATTRIBUTE_NAMES, {
-  KOTLIN_MUTABLE_VARIABLE: "identifier",
-  KOTLIN_PACKAGE_PROPERTY: "field",
-  KOTLIN_SYNTHETIC_EXTENSION_PROPERTY: "field",
-  KOTLIN_EXTENSION_FUNCTION_CALL: "functionCall",
-  KOTLIN_NAMED_ARGUMENT: "parameter",
-  KOTLIN_OBJECT: "className",
+  KOTLIN_MUTABLE_VARIABLE: "kotlin.identifier",
+  KOTLIN_PACKAGE_PROPERTY: "kotlin.field",
+  KOTLIN_SYNTHETIC_EXTENSION_PROPERTY: "kotlin.field",
+  KOTLIN_EXTENSION_FUNCTION_CALL: "kotlin.functionCall",
+  KOTLIN_NAMED_ARGUMENT: "kotlin.parameter",
+  KOTLIN_OBJECT: "kotlin.className",
+  CLASS_NAME_ATTRIBUTES: "className",
+  PHP_KEYWORD: "php.keyword",
+  PHP_VAR: "php.identifier",
+  PHP_PARAMETER: "php.parameter",
+  PHP_CLASS: "php.className",
+  PHP_CONSTANT: "php.constant",
+  PHP_INSTANCE_FIELD: "php.field",
+  PHP_STATIC_FIELD: "php.staticField",
+  PHP_FUNCTION: "php.functionDeclaration",
+  PHP_FUNCTION_CALL: "php.functionCall",
+  PHP_INSTANCE_METHOD: "php.functionCall",
+  "PHP_PREDEFINED SYMBOL": "php.predefined",
+  PHP_NUMBER: "php.number",
+  PHP_STRING: "php.string",
+  PHP_ESCAPE_SEQUENCE: "php.escape",
+  PHP_COMMENT: "php.lineComment",
+  PHP_DOC_COMMENT_ID: "php.docComment",
+  PHP_DOC_TAG: "php.metadata",
+  PHP_OPERATION_SIGN: "php.operator",
+  PHP_BRACKETS: "php.brackets",
+  PHP_COMMA: "php.separator",
+  PHP_SEMICOLON: "php.separator",
+  PHP_TAG: "php.scriptTag",
 });
 
 const COLOR_NAMES: Record<string, [string, "foreground" | "background"]> = {
@@ -147,6 +170,22 @@ export function parseIcls(xml: string): { scheme: CustomColorScheme; applied: nu
   )
     throw new Error("Invalid .icls color scheme");
   const attributes: Record<string, TextAttributesOverride> = {};
+  const entries = new Map(
+    children(root, "attributes").flatMap((section) =>
+      children(section, "option").map((entry) => [entry.getAttribute("name"), entry] as const),
+    ),
+  );
+  const inheritedValue = (entry: Element): Element | undefined => {
+    const seen = new Set<Element>();
+    let current: Element | undefined = entry;
+    while (current && !seen.has(current)) {
+      seen.add(current);
+      const value = children(current, "value")[0];
+      if (value) return value;
+      current = entries.get(current.getAttribute("baseAttributes"));
+    }
+    return undefined;
+  };
   let applied = 0;
   let skipped = 0;
   const merge = (id: string, value: TextAttributesOverride) => {
@@ -171,11 +210,14 @@ export function parseIcls(xml: string): { scheme: CustomColorScheme; applied: nu
           skipped++;
           continue;
         }
-        const value = children(entry, "value")[0];
+        const value = inheritedValue(entry);
         if (!value) {
           skipped++;
           continue;
         }
+        const attr = ATTRIBUTES.find((a) => a.id === id)!;
+        // An explicit TextAttributes value defaults to Font.PLAIN, not the last alias's style.
+        if (attr.token) merge(id, { bold: false, italic: false });
         for (const option of children(value, "option")) {
           const name = option.getAttribute("name");
           const raw = option.getAttribute("value");
@@ -188,7 +230,6 @@ export function parseIcls(xml: string): { scheme: CustomColorScheme; applied: nu
                 : name === "EFFECT_COLOR"
                   ? "effectColor"
                   : undefined;
-          const attr = ATTRIBUTES.find((a) => a.id === id)!;
           const supported =
             field === "foreground"
               ? !!attr.fg
@@ -212,13 +253,17 @@ export function parseIcls(xml: string): { scheme: CustomColorScheme; applied: nu
   const bg = attributes.text?.background;
   const rgb = bg ? [1, 3, 5].map((i) => parseInt(bg.slice(i, i + 2), 16)) : [255, 255, 255];
   const dark = rgb[0]! * 0.299 + rgb[1]! * 0.587 + rgb[2]! * 0.114 < 128;
-  const parent = /darcula|dark/i.test(parentName)
-    ? "dark"
-    : /default|light/i.test(parentName)
-      ? "light"
-      : dark
-        ? "dark"
-        : "light";
+  const parent = bg
+    ? dark
+      ? "dark"
+      : "light"
+    : /darcula|dark/i.test(parentName)
+      ? "dark"
+      : /default|light/i.test(parentName)
+        ? "light"
+        : dark
+          ? "dark"
+          : "light";
   return { scheme: { name: root.getAttribute("name")!.trim(), parent, attributes }, applied, skipped };
 }
 
@@ -290,6 +335,7 @@ export function exportIcls(
     if (isHexColor(c)) colors.push(`    <option name="${key}" value="${exportColor(c)}" />`);
   }
   for (const attr of ATTRIBUTES) {
+    if (attr.language && !custom?.attributes[attr.id] && !overrides[attr.id]) continue;
     const key = Object.keys(ATTRIBUTE_NAMES).find((key) => ATTRIBUTE_NAMES[key] === attr.id);
     if (!key) continue;
     const v = values(attr);
diff --git a/src/platform/languageSettings.ts b/src/platform/languageSettings.ts
index 7f458a180..ad9fd4eb5 100644
--- a/src/platform/languageSettings.ts
+++ b/src/platform/languageSettings.ts
@@ -103,6 +103,7 @@ export interface LanguagesValid {
     jdtlsJdk: string;
     jdtlsVmArgs: string;
     gradle: {
+      linkedProjects: string[] | null;
       jvm: string;
       distribution: "wrapper" | "local";
       home: string;
@@ -115,6 +116,7 @@ export interface LanguagesValid {
       userSettings: string;
       localRepository: string;
       unlinkedProjects: string[];
+      linkedProjects: string[];
       daemon: boolean;
       mvndHome: string;
     };
@@ -160,8 +162,16 @@ export const DEFAULT_LANGUAGES: LanguagesValid = {
     jdk: "",
     jdtlsJdk: "",
     jdtlsVmArgs: "",
-    gradle: { jvm: "", distribution: "wrapper", home: "", userHome: "", runUsing: "gradle" },
-    maven: { home: "", userSettings: "", localRepository: "", unlinkedProjects: [], daemon: false, mvndHome: "" },
+    gradle: { linkedProjects: null, jvm: "", distribution: "wrapper", home: "", userHome: "", runUsing: "gradle" },
+    maven: {
+      home: "",
+      userSettings: "",
+      localRepository: "",
+      unlinkedProjects: [],
+      linkedProjects: [],
+      daemon: false,
+      mvndHome: "",
+    },
   },
   markdown: { previewFontSize: null },
 };
@@ -292,6 +302,9 @@ export function validateLanguages(raw: unknown): LanguagesValid {
       jdtlsJdk: text(java.jdtlsJdk, d.java.jdtlsJdk),
       jdtlsVmArgs: text(java.jdtlsVmArgs, d.java.jdtlsVmArgs),
       gradle: {
+        linkedProjects: Array.isArray(gradle.linkedProjects)
+          ? gradle.linkedProjects.filter((p): p is string => typeof p === "string")
+          : null,
         jvm: text(gradle.jvm, d.java.gradle.jvm),
         distribution: oneOf(gradle.distribution, ["wrapper", "local"] as const, d.java.gradle.distribution),
         home: text(gradle.home, d.java.gradle.home),
@@ -303,6 +316,7 @@ export function validateLanguages(raw: unknown): LanguagesValid {
         userSettings: text(maven.userSettings, d.java.maven.userSettings),
         localRepository: text(maven.localRepository, d.java.maven.localRepository),
         unlinkedProjects: folders(maven.unlinkedProjects),
+        linkedProjects: folders(maven.linkedProjects),
         daemon: bool(maven.daemon, d.java.maven.daemon),
         mvndHome: text(maven.mvndHome, d.java.maven.mvndHome),
       },
diff --git a/src/platform/locales/en.json b/src/platform/locales/en.json
index 05325107b..18b229171 100644
--- a/src/platform/locales/en.json
+++ b/src/platform/locales/en.json
@@ -50,6 +50,12 @@
   "app.lightEdit.openProjectTooltip": "Open {folder} as a project",
   "app.log.failed": "Cannot show the log",
   "app.project.opening": "Opening {name}…",
+  "app.terminateProcesses.bodyMany": "Do you want to terminate these {count} processes: {names}?",
+  "app.terminateProcesses.bodyOne": "Do you want to terminate the process '{name}'?",
+  "app.terminateProcesses.dontAsk": "Don't ask again",
+  "app.terminateProcesses.terminate": "Terminate",
+  "app.terminateProcesses.titleMany": "Processes Are Running",
+  "app.terminateProcesses.titleOne": "Process '{name}' Is Running",
   "app.title.default": "OpenIDEA",
   "app.unsaved.body": "{count, plural, one {# file has} other {# files have}} unsaved changes in {project}. Save before closing?",
   "app.unsaved.discard": "Don't Save",
diff --git a/src/platform/locales/text/en.json b/src/platform/locales/text/en.json
new file mode 100644
index 000000000..60c7fb0b8
--- /dev/null
+++ b/src/platform/locales/text/en.json
@@ -0,0 +1,8 @@
+{
+  "Connect through:": "Connect through:",
+  "Connect through": "Connect through",
+  "WSL distribution:": "WSL distribution:",
+  "WSL distribution": "WSL distribution",
+  "Project runs on {label}": "Project runs on {label}",
+  "Forwarding ports is not supported in a WSL project yet": "Forwarding ports is not supported in a WSL project yet"
+}
diff --git a/src/platform/locales/text/es.json b/src/platform/locales/text/es.json
index be1386c7d..52e968ef0 100644
--- a/src/platform/locales/text/es.json
+++ b/src/platform/locales/text/es.json
@@ -1,4 +1,8 @@
 {
+  "Brackets": "Corchetes y paréntesis",
+  "Comma and semicolon": "Coma y punto y coma",
+  "PHP tags": "Etiquetas PHP",
+  "Static field": "Campo estático",
   "Unity": "Unity",
   "Show Meta Files": "Mostrar archivos meta",
   "Show Generated Files": "Mostrar archivos generados",
@@ -5803,18 +5807,18 @@
   "Unsigned": "Sin firmar",
   "Roll Back to {previousVersion}": "Revertir a {previousVersion}",
   "Install Plugin from Package File…": "Instalar plugin desde archivo de paquete…",
-  "Import Theme from IntelliJ IDE…": "Importar tema desde IntelliJ IDE…",
+  "Import Theme from JetBrains IDE…": "Importar tema desde un IDE de JetBrains…",
   "Import IntelliJ Theme from File…": "Importar tema de IntelliJ desde archivo…",
-  "Import Theme from IntelliJ IDE": "Importar tema desde IntelliJ IDE",
+  "Import Theme from JetBrains IDE": "Importar tema desde un IDE de JetBrains",
   "Import IntelliJ Theme": "Importar tema de IntelliJ",
   "IntelliJ theme plugin or theme file": "Plugin de tema o archivo de tema de IntelliJ",
   "Could not import the IntelliJ theme": "No se pudo importar el tema de IntelliJ",
   "Import": "Importar",
   "In use": "En uso",
-  "IntelliJ themes": "Temas de IntelliJ",
-  "Looking for IntelliJ themes": "Buscando temas de IntelliJ",
-  "Looking for IntelliJ themes…": "Buscando temas de IntelliJ…",
-  "Theme plugins installed in the JetBrains IDEs on this computer. Importing a theme brings every theme of its plugin and applies the chosen one. Colours without an OpenIDEA counterpart keep the default theme colours.": "Plugins de temas instalados en los IDE de JetBrains en este equipo. Al importar un tema se incluyen todos los temas de su plugin y se aplica el elegido. Los colores sin equivalente en OpenIDEA conservan los colores del tema predeterminado.",
+  "JetBrains theme plugins": "Plugins de temas de JetBrains",
+  "Looking for JetBrains themes": "Buscando temas de JetBrains",
+  "Looking for JetBrains themes…": "Buscando temas de JetBrains…",
+  "Theme plugins installed in the JetBrains IDEs on this computer. Importing one installs it with all its themes; choose the theme to use in Settings › Appearance. Colours without an OpenIDEA counterpart keep the default theme colours.": "Plugins de temas instalados en los IDE de JetBrains en este equipo. Al importar uno se instala con todos sus temas; elija el tema que desea usar en Configuración › Apariencia. Los colores sin equivalente en OpenIDEA conservan los colores del tema predeterminado.",
   "1 theme": "1 tema",
   "{count} themes": "{count} temas",
   "No theme plugins found in JetBrains IDEs on this computer. Choose a theme plugin downloaded from the JetBrains Marketplace (.jar or .zip) or a .theme.json file instead.": "No se encontraron plugins de temas en los IDE de JetBrains en este equipo. En su lugar, elija un plugin de tema descargado de JetBrains Marketplace (.jar o .zip) o un archivo .theme.json.",
@@ -6160,9 +6164,6 @@
   "Shallow history boundary": "Límite de historial superficial (shallow)",
   "All Parents": "Todos los padres",
   "Show Commit Bookmark": "Mostrar marcador de confirmación",
-  "Indexing Git log: {indexed} / {total}": "Indexando registro de Git: {indexed} / {total}",
-  "Resume Indexing": "Reanudar indexación",
-  "Pause Indexing": "Pausar indexación",
   "Incompatible": "Incompatible",
   "Needs plugin API {engine}. Update OpenIDEA to install it.": "Requiere la API de plugins {engine}. Actualice OpenIDEA para instalarlo.",
   "Icon Themes": "Temas de iconos",
diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.json
index 3bae28ce6..dc7007289 100644
--- a/src/platform/locales/text/zh.json
+++ b/src/platform/locales/text/zh.json
@@ -1,4 +1,26 @@
 {
+  "Group actions": "分组操作",
+  "New Project Group": "新建项目组",
+  "Group name:": "组名称：",
+  "New Group…": "新建组…",
+  "Remove from '{current}'": "从“{current}”移除",
+  "Move to Group": "移动到组",
+  "Rename Group…": "重命名组…",
+  "Rename Project Group": "重命名项目组",
+  "New Project Group…": "新建项目组…",
+  "Remove Group": "移除组",
+  "Cannot save project groups": "无法保存项目组",
+  "Enter a group name": "请输入组名称",
+  "A group named '{name}' already exists": "名为“{name}”的组已存在",
+  "Link Gradle Projects": "关联 Gradle 项目",
+  "Unlink Gradle Project": "取消关联 Gradle 项目",
+  "Unlink Gradle project?": "取消关联 Gradle 项目？",
+  "Remove this build from Gradle? Files will remain in the Project view; link its build file again to restore it.": "从 Gradle 中移除此构建？文件将保留在项目视图中；重新关联其构建文件即可恢复。",
+  "Gradle build files": "Gradle 构建文件",
+  "Brackets": "括号",
+  "Comma and semicolon": "逗号和分号",
+  "PHP tags": "PHP 标签",
+  "Static field": "静态字段",
   "Unity": "Unity 项目",
   "Show Meta Files": "显示 Meta 文件",
   "Show Generated Files": "显示生成的文件",
@@ -140,6 +162,10 @@
   "Fixup…": "修补提交…",
   "Step Over": "单步跳过",
   "Step Out": "单步跳出",
+  "Hot Reload": "热重载",
+  "Hot Restart": "热重启",
+  "Flutter: inject the changed sources into the running app": "Flutter：将改动后的源码注入正在运行的应用",
+  "Flutter: restart the app, discarding its state": "Flutter：重启应用，丢弃当前状态",
   "Zoom In": "放大",
   "Zoom Out": "缩小",
   "Actual Size": "实际大小",
@@ -468,6 +494,7 @@
   "Color scheme preview": "配色方案预览",
   "Color theme": "颜色主题",
   "Column": "列",
+  "Column Headers": "列标题",
   "Column Selection Mode": "列选择模式",
   "Columns": "列",
   "Comma-separated column numbers, e.g. 80, 100.": "逗号分隔的列号，例如 80, 100。",
@@ -2680,6 +2707,7 @@
   "New Worktree…": "新建工作树…",
   "Worktrees…": "工作树…",
   "Worktrees": "工作树",
+  "Current worktree": "当前工作树",
   "New Worktree": "新建工作树",
   "Git Remotes": "Git 远程",
   "Define Remote": "定义远程",
@@ -4443,6 +4471,12 @@
   "Remote Development": "远程开发",
   "The project runs on the remote host; the IDE backend is installed there on first use.": "项目在远程主机上运行，首次使用时会在该主机上安装 IDE 后端。",
   "SSH configuration:": "SSH 配置：",
+  "Connect through:": "连接方式：",
+  "Connect through": "连接方式",
+  "WSL distribution:": "WSL 发行版：",
+  "WSL distribution": "WSL 发行版",
+  "Project runs on {label}": "项目运行于 {label}",
+  "Forwarding ports is not supported in a WSL project yet": "WSL 项目暂不支持端口转发",
   "No SSH configurations": "没有 SSH 配置",
   "Project directory:": "项目目录：",
   "Remote Development…": "远程开发…",
@@ -4906,6 +4940,7 @@
   "The registry has no agents for this system": "Registry 中没有适用于此系统的 Agent",
   "{version} available": "{version} 可用",
   "Installing {name} {version}…": "正在安装 {name} {version}…",
+  "Installing {name} in the background…": "正在后台安装 {name}…",
   "Website": "网站",
   "Removing…": "正在移除…",
   "Registry agents": "Registry Agent",
@@ -5808,18 +5843,18 @@
   "Unsigned": "未签名",
   "Roll Back to {previousVersion}": "回滚到 {previousVersion}",
   "Install Plugin from Package File…": "从插件包文件安装…",
-  "Import Theme from IntelliJ IDE…": "从 IntelliJ IDE 导入主题…",
+  "Import Theme from JetBrains IDE…": "从 JetBrains IDE 导入主题…",
   "Import IntelliJ Theme from File…": "从文件导入 IntelliJ 主题…",
-  "Import Theme from IntelliJ IDE": "从 IntelliJ IDE 导入主题",
+  "Import Theme from JetBrains IDE": "从 JetBrains IDE 导入主题",
   "Import IntelliJ Theme": "导入 IntelliJ 主题",
   "IntelliJ theme plugin or theme file": "IntelliJ 主题插件或主题文件",
   "Could not import the IntelliJ theme": "无法导入 IntelliJ 主题",
   "Import": "导入",
   "In use": "使用中",
-  "IntelliJ themes": "IntelliJ 主题",
-  "Looking for IntelliJ themes": "正在查找 IntelliJ 主题",
-  "Looking for IntelliJ themes…": "正在查找 IntelliJ 主题…",
-  "Theme plugins installed in the JetBrains IDEs on this computer. Importing a theme brings every theme of its plugin and applies the chosen one. Colours without an OpenIDEA counterpart keep the default theme colours.": "此计算机上 JetBrains IDE 中安装的主题插件。导入某个主题会一并导入其插件的全部主题，并应用所选主题。没有对应 OpenIDEA 颜色的项保留默认主题的颜色。",
+  "JetBrains theme plugins": "JetBrains 主题插件",
+  "Looking for JetBrains themes": "正在查找 JetBrains 主题",
+  "Looking for JetBrains themes…": "正在查找 JetBrains 主题…",
+  "Theme plugins installed in the JetBrains IDEs on this computer. Importing one installs it with all its themes; choose the theme to use in Settings › Appearance. Colours without an OpenIDEA counterpart keep the default theme colours.": "此计算机上 JetBrains IDE 中安装的主题插件。导入后会安装该插件及其全部主题；要使用的主题请在“设置 › 外观”中选择。没有对应 OpenIDEA 颜色的项保留默认主题的颜色。",
   "1 theme": "1 个主题",
   "{count} themes": "{count} 个主题",
   "No theme plugins found in JetBrains IDEs on this computer. Choose a theme plugin downloaded from the JetBrains Marketplace (.jar or .zip) or a .theme.json file instead.": "在此计算机上的 JetBrains IDE 中未找到主题插件。请改为选择从 JetBrains Marketplace 下载的主题插件（.jar 或 .zip）或 .theme.json 文件。",
@@ -6165,9 +6200,6 @@
   "Shallow history boundary": "浅克隆历史边界",
   "All Parents": "所有父提交",
   "Show Commit Bookmark": "显示提交书签",
-  "Indexing Git log: {indexed} / {total}": "正在索引 Git 日志：{indexed} / {total}",
-  "Resume Indexing": "继续索引",
-  "Pause Indexing": "暂停索引",
   "Incompatible": "不兼容",
   "Needs plugin API {engine}. Update OpenIDEA to install it.": "需要插件 API {engine}。请更新 OpenIDEA 后再安装。",
   "Icon Themes": "图标主题",
@@ -6183,5 +6215,32 @@
   "Plugin update available": "有插件可更新",
   "{length} plugin updates available": "{length} 个插件可更新",
   "Updated {updated} plugins": "已更新 {updated} 个插件",
-  "This version is signed with a different key than the installed one, and the publisher's earlier key doesn't vouch for it. Only continue if you know the publisher changed keys.": "此版本的签名密钥与已安装的版本不同，且发布者之前的密钥没有为它背书。只有在确认发布者更换了密钥时才继续。"
+  "This version is signed with a different key than the installed one, and the publisher's earlier key doesn't vouch for it. Only continue if you know the publisher changed keys.": "此版本的签名密钥与已安装的版本不同，且发布者之前的密钥没有为它背书。只有在确认发布者更换了密钥时才继续。",
+  "Search in results": "在结果中搜索",
+  "Bad regex": "正则表达式无效",
+  "Filter rows": "筛选行",
+  "Result pages": "结果分页",
+  "First Page": "第一页",
+  "Count rows": "统计行数",
+  "Last Page": "最后一页",
+  "{first}-{last} of {total}": "{first}-{last}，共 {total}",
+  "Model & effort settings": "模型与推理强度",
+  "Logcat": "Logcat 日志",
+  "Device": "设备",
+  "No devices": "没有设备",
+  "Minimum level": "最低级别",
+  "Filter log lines": "过滤日志行",
+  "Filter, e.g. tag:glide -message:bitmap level:error": "过滤，例如 tag:glide -message:bitmap level:error",
+  "tag: · message: · pid: · level: · -term · a|b · (a|b) -c · message~:regex · ↑ for history": "tag: · message: · pid: · level: · -term · a|b · (a|b) -c · message~:regex · ↑ 调出历史",
+  "Filter history": "过滤历史",
+  "Resume": "继续",
+  "Following the end (click to stop)": "正在跟随末尾（点击停止）",
+  "Scroll to end": "滚动到末尾",
+  "Refresh devices": "刷新设备",
+  "No Android devices": "没有 Android 设备",
+  "Looking for devices…": "正在查找设备…",
+  "Connect a device over USB, or start an emulator. Logcat uses the Android SDK's adb.": "通过 USB 连接设备，或启动模拟器。Logcat 使用 Android SDK 的 adb。",
+  "No lines match the filter": "没有符合过滤条件的日志行",
+  "Streaming": "正在接收",
+  "Idle": "空闲"
 }
diff --git a/src/platform/locales/textCatalog.test.ts b/src/platform/locales/textCatalog.test.ts
index 586912107..a98fdceed 100644
--- a/src/platform/locales/textCatalog.test.ts
+++ b/src/platform/locales/textCatalog.test.ts
@@ -108,6 +108,7 @@ const UNTRANSLATED = new Set<string>([
   "loopvar,rangefunc",
   // SSH and run-target placeholders
   "SSH",
+  "WSL",
   "example.com",
   "java",
   "node",
diff --git a/src/platform/locales/zh.json b/src/platform/locales/zh.json
index 3dbaef005..6cf81d316 100644
--- a/src/platform/locales/zh.json
+++ b/src/platform/locales/zh.json
@@ -50,6 +50,12 @@
   "app.lightEdit.openProjectTooltip": "将 {folder} 作为项目打开",
   "app.log.failed": "无法显示日志",
   "app.project.opening": "正在打开 {name}…",
+  "app.terminateProcesses.bodyMany": "是否要终止这 {count} 个进程：{names}？",
+  "app.terminateProcesses.bodyOne": "是否要终止进程“{name}”？",
+  "app.terminateProcesses.dontAsk": "不再询问",
+  "app.terminateProcesses.terminate": "终止",
+  "app.terminateProcesses.titleMany": "有进程正在运行",
+  "app.terminateProcesses.titleOne": "进程“{name}”正在运行",
   "app.title.default": "OpenIDEA",
   "app.unsaved.body": "{project} 中有 {count} 个文件尚未保存。关闭前是否保存？",
   "app.unsaved.discard": "不保存",
diff --git a/src/platform/projectPresentation.test.ts b/src/platform/projectPresentation.test.ts
index 68a3d2643..e2dc62c1f 100644
--- a/src/platform/projectPresentation.test.ts
+++ b/src/platform/projectPresentation.test.ts
@@ -2,7 +2,7 @@ import { describe, it, expect } from "vitest";
 import { buildPresentation, isModuleFolder, moduleFolderIcon } from "./projectPresentation";
 import type { BuildModel } from "./ipc";
 
-const model = (partial: unknown) => ({ maven: null, gradle: null, ...(partial as object) }) as BuildModel;
+const model = (partial: unknown) => ({ maven: null, gradle: [], ...(partial as object) }) as BuildModel;
 describe("build presentation context", () => {
   it.each(["maven", "gradle"] as const)("uses distinct %s root and nested module glyphs", (tool) => {
     const modules = new Map([
@@ -45,12 +45,14 @@ describe("build presentation context", () => {
   it("includes Gradle root and nested project directories", () => {
     const context = buildPresentation(
       model({
-        gradle: {
-          projects: [
-            { dir: "", tasks: [] },
-            { dir: "lib/core", tasks: [] },
-          ],
-        },
+        gradle: [
+          {
+            projects: [
+              { dir: "", tasks: [] },
+              { dir: "lib/core", tasks: [] },
+            ],
+          },
+        ],
       }),
     );
     expect([...context.modules]).toEqual([
@@ -67,9 +69,27 @@ describe("build presentation context", () => {
         }),
       ).spring,
     ).toBe(true);
-    expect(buildPresentation(model({ gradle: { projects: [{ dir: "", tasks: [{ name: "bootRun" }] }] } })).spring).toBe(
-      true,
-    );
+    expect(
+      buildPresentation(model({ gradle: [{ projects: [{ dir: "", tasks: [{ name: "bootRun" }] }] }] })).spring,
+    ).toBe(true);
   });
   it("keeps plain folders plain", () => expect(buildPresentation(model({})).modules.size).toBe(0));
 });
+
+it("includes modules and Spring tasks from every independently linked Gradle build", () => {
+  const context = buildPresentation(
+    model({
+      gradle: [
+        {
+          projects: [
+            { dir: "first", tasks: [] },
+            { dir: "first/app", tasks: [] },
+          ],
+        },
+        { projects: [{ dir: "second", tasks: [{ name: "bootRun" }] }] },
+      ],
+    }),
+  );
+  expect([...context.modules.keys()]).toEqual(["first", "first/app", "second"]);
+  expect(context.spring).toBe(true);
+});
diff --git a/src/platform/projectPresentation.ts b/src/platform/projectPresentation.ts
index cc6f4f103..1a588eb17 100644
--- a/src/platform/projectPresentation.ts
+++ b/src/platform/projectPresentation.ts
@@ -14,13 +14,13 @@ export const useBuildPresentation = create<BuildPresentation>(() => EMPTY);
 export function buildPresentation(model: BuildModel): BuildPresentation {
   const modules = new Map<string, "maven" | "gradle">();
   for (const p of model.maven?.projects ?? []) modules.set(p.dir, "maven");
-  for (const p of model.gradle?.projects ?? []) modules.set(p.dir, "gradle");
+  for (const p of (model.gradle ?? []).flatMap((g) => g.projects)) modules.set(p.dir, "gradle");
   const spring =
     (model.maven?.projects ?? []).some(
       (p) =>
         p.dependencies.some((d) => d.groupId.startsWith("org.springframework")) ||
         p.plugins.some((p) => p.groupId.startsWith("org.springframework")),
-    ) || (model.gradle?.projects ?? []).some((p) => p.tasks.some((t) => t.name === "bootRun"));
+    ) || (model.gradle ?? []).some((g) => g.projects.some((p) => p.tasks.some((t) => t.name === "bootRun")));
   return { modules, spring };
 }
 
diff --git a/src/platform/remote.ts b/src/platform/remote.ts
index c6947cf9c..655cf5043 100644
--- a/src/platform/remote.ts
+++ b/src/platform/remote.ts
@@ -8,9 +8,18 @@ import { confirmProjectTrust } from "./projectTrust";
 import { Channel, type InvokeArgs, type InvokeOptions } from "@tauri-apps/api/core";
 import { invokeLocal, setInvokeRoute, type InvokeRoute } from "./tauriCore";
 import { create } from "zustand";
-import { call, commands, isTauri, type ChannelFrame, type RemoteProgress, type RemoteSession } from "./ipc";
+import {
+  call,
+  commands,
+  isTauri,
+  type ChannelFrame,
+  type RemoteProgress,
+  type RemoteSession,
+  type RemoteTarget,
+} from "./ipc";
 import { isClientSetting, overlayClientSettings } from "./clientSettings";
 import type { Settings } from "./ipc";
+import { usePlatform } from "./platformInfo";
 import { useProject } from "./project";
 
 interface RemoteState {
@@ -21,6 +30,7 @@ export const useRemote = create<RemoteState>(() => ({ session: null }));
 
 let routed = new Set<string>();
 let nextChannel = 1;
+const BUILD_MODEL_COMMANDS = new Set(["build_model", "build_sync", "gradle_link_projects", "gradle_unlink_projects"]);
 
 /**
  * The arguments with each `Channel` replaced by `{ $channel: id }`, and the
@@ -48,7 +58,12 @@ async function remoteInvoke(cmd: string, args?: InvokeArgs, options?: InvokeOpti
   const onChannel = new Channel<ChannelFrame>();
   onChannel.onmessage = (frame) => channels.get(frame.id)?.onmessage(JSON.parse(frame.data));
   const result = await invokeLocal<string>("remote_invoke", { cmd, args: json, onChannel }, options);
-  return JSON.parse(result);
+  const value = JSON.parse(result);
+  // Released servers predating independent Gradle builds return a single build.
+  if (BUILD_MODEL_COMMANDS.has(cmd) && value?.gradle && !Array.isArray(value.gradle)) {
+    value.gradle = [value.gradle];
+  }
+  return value;
 }
 
 /**
@@ -119,6 +134,11 @@ export function isRemoteWindow(): boolean {
   return useRemote.getState().session !== null;
 }
 
+/** The OS this window's commands run on: the remote server's, else this desktop's (`usePlatform`). */
+export function hostOs(): string {
+  return useRemote.getState().session?.os ?? usePlatform.getState().os;
+}
+
 /** Re-attaches after a reload (the backend keeps the connection per window). */
 export async function restoreRemote(): Promise<RemoteSession | null> {
   if (!isTauri()) return null;
@@ -133,19 +153,19 @@ export const useRemoteProgress = create<{ progress: RemoteProgress | null; locat
   location: null,
 }));
 
-/** Opens `path` on the host of SSH configuration `sshConfig` in this window. */
-export async function connectRemote(sshConfig: string, path: string) {
+/** Opens `path` of `target` (an SSH host or a WSL distribution) in this window. */
+export async function connectRemote(target: RemoteTarget, path: string) {
   useProject.setState({ opening: true });
   const onProgress = new Channel<RemoteProgress>();
   onProgress.onmessage = (progress) => useRemoteProgress.setState({ progress });
   useRemoteProgress.setState({
     progress: { stage: "connecting", fraction: null },
-    location: remoteLocation(sshConfig, path),
+    location: remoteLocation(target, path),
   });
   try {
-    const r = await call(commands.remoteConnect(sshConfig, path, onProgress));
-    enableRemote({ sshConfig: r.sshConfig, root: r.root, host: r.host, commands: r.commands });
-    if (takeLegacyRemoteTrust(r.sshConfig, path, r.host)) {
+    const r = await call(commands.remoteConnect(target, path, onProgress));
+    enableRemote({ target: r.target, root: r.root, host: r.host, os: r.os, commands: r.commands });
+    if (takeLegacyRemoteTrust(r.target, path, r.host)) {
       const status = await call(commands.projectTrustStatus(r.root));
       if (!status.decided) await call(commands.projectTrustSet(r.root, true, false));
     }
@@ -161,7 +181,7 @@ export async function connectRemote(sshConfig: string, path: string) {
     r.project.settings = await clientSettings(r.project.settings);
     useProject.setState({ project: r.project, settings: r.project.settings });
     rememberRemote({
-      sshConfig: r.sshConfig,
+      target: r.target,
       path: r.root,
       name: r.project.name,
       host: r.host,
@@ -182,32 +202,54 @@ export async function disconnectRemote() {
 }
 
 // ---------------------------------------------------------------------------
-// Remote project locations: `ssh://<configuration id>/<absolute path>`, what the
-// session and the recent projects remember for a remote window.
+// Remote project locations: `ssh://<configuration id>/<absolute path>` or
+// `wsl://<distribution>/<absolute path>`, what the session and the recent projects
+// remember for a remote window.
 
-const SCHEME = "ssh://";
+const SCHEMES = { ssh: "ssh://", wsl: "wsl://" } as const;
 
-export function remoteLocation(sshConfig: string, path: string): string {
-  return `${SCHEME}${encodeURIComponent(sshConfig)}${path.startsWith("/") ? "" : "/"}${path}`;
+/** The SSH configuration id or the WSL distribution name. */
+export function targetName(target: RemoteTarget): string {
+  return target.kind === "ssh" ? target.config : target.distro;
 }
 
-export function parseRemoteLocation(location: string): { sshConfig: string; path: string } | null {
-  if (!location.startsWith(SCHEME)) return null;
-  const rest = location.slice(SCHEME.length);
+export function sameTarget(a: RemoteTarget, b: RemoteTarget): boolean {
+  return a.kind === b.kind && targetName(a) === targetName(b);
+}
+
+export function remoteLocation(target: RemoteTarget, path: string): string {
+  return `${SCHEMES[target.kind]}${encodeURIComponent(targetName(target))}${path.startsWith("/") ? "" : "/"}${path}`;
+}
+
+export function parseRemoteLocation(location: string): { target: RemoteTarget; path: string } | null {
+  const kind = (Object.keys(SCHEMES) as (keyof typeof SCHEMES)[]).find((k) => location.startsWith(SCHEMES[k]));
+  if (!kind) return null;
+  const rest = location.slice(SCHEMES[kind].length);
   const slash = rest.indexOf("/");
   if (slash <= 0) return null;
-  return { sshConfig: decodeURIComponent(rest.slice(0, slash)), path: rest.slice(slash) };
+  const name = decodeURIComponent(rest.slice(0, slash));
+  const target: RemoteTarget = kind === "ssh" ? { kind, config: name } : { kind, distro: name };
+  return { target, path: rest.slice(slash) };
+}
+
+/**
+ * The remote project a saved location stands for: a `ssh://` / `wsl://` location, or a
+ * `\\wsl.localhost\<distro>\…` folder remembered before WSL projects existed (it is a WSL
+ * project, not a network folder). `null` for a plain local path.
+ */
+export async function resolveRemoteLocation(location: string): Promise<{ target: RemoteTarget; path: string } | null> {
+  return parseRemoteLocation(location) ?? (await commands.wslResolve(location).catch(() => null));
 }
 
 /** The location of this window's project: remote, else its local root. */
 export function projectLocation(root: string | null | undefined): string | null {
   if (!root) return null;
   const session = useRemote.getState().session;
-  return session && session.root === root ? remoteLocation(session.sshConfig, root) : root;
+  return session && session.root === root ? remoteLocation(session.target, root) : root;
 }
 
 export interface RecentRemote {
-  sshConfig: string;
+  target: RemoteTarget;
   path: string;
   name: string;
   /** `user@host:port` when it was opened. */
@@ -230,12 +272,23 @@ export function initializeRemoteTrustMigration() {
   }
 }
 
-export function takeLegacyRemoteTrust(sshConfig: string, path: string, host: string): boolean {
+/** An entry as stored: before WSL it carried `sshConfig` instead of `target`. */
+function normalize(entry: RecentRemote & { sshConfig?: string }): RecentRemote | null {
+  if (!entry || !entry.path) return null;
+  const target = entry.target ?? (entry.sshConfig ? { kind: "ssh" as const, config: entry.sshConfig } : null);
+  return target ? { ...entry, target } : null;
+}
+
+/** Whether `path` on SSH `target` was remembered before the trust prompt existed (WSL never was). */
+export function takeLegacyRemoteTrust(target: RemoteTarget, path: string, host: string): boolean {
+  if (target.kind !== "ssh") return false;
   try {
     const value: unknown = JSON.parse(localStorage.getItem(TRUST_MIGRATION_KEY) ?? "[]");
     if (!Array.isArray(value)) return false;
-    const matches = (entry: RecentRemote) =>
-      entry?.sshConfig === sshConfig && entry.path === path && entry.host === host;
+    const matches = (stored: RecentRemote) => {
+      const entry = normalize(stored);
+      return entry !== null && sameTarget(entry.target, target) && entry.path === path && entry.host === host;
+    };
     const found = value.some(matches);
     localStorage.setItem(TRUST_MIGRATION_KEY, JSON.stringify(value.filter((entry) => !matches(entry))));
     return found;
@@ -247,7 +300,7 @@ export function takeLegacyRemoteTrust(sshConfig: string, path: string, host: str
 export function recentRemotes(): RecentRemote[] {
   try {
     const list = JSON.parse(localStorage.getItem(RECENT_KEY) ?? "[]") as unknown;
-    return Array.isArray(list) ? (list as RecentRemote[]).filter((r) => r && r.sshConfig && r.path) : [];
+    return Array.isArray(list) ? list.map(normalize).filter((r): r is RecentRemote => r !== null) : [];
   } catch {
     return [];
   }
@@ -261,15 +314,15 @@ function saveRemotes(list: RecentRemote[]) {
   }
 }
 
-const sameRemote = (a: Pick<RecentRemote, "sshConfig" | "path">, b: Pick<RecentRemote, "sshConfig" | "path">) =>
-  a.sshConfig === b.sshConfig && a.path === b.path;
+const sameRemote = (a: Pick<RecentRemote, "target" | "path">, b: Pick<RecentRemote, "target" | "path">) =>
+  sameTarget(a.target, b.target) && a.path === b.path;
 
 export function rememberRemote(entry: RecentRemote) {
   saveRemotes([entry, ...recentRemotes().filter((r) => !sameRemote(r, entry))]);
 }
 
-export function forgetRemote(sshConfig: string, path: string) {
-  saveRemotes(recentRemotes().filter((r) => !sameRemote(r, { sshConfig, path })));
+export function forgetRemote(target: RemoteTarget, path: string) {
+  saveRemotes(recentRemotes().filter((r) => !sameRemote(r, { target, path })));
 }
 
 // Any way of leaving the remote project (Close Project, opening a local one) ends remote routing.
diff --git a/src/platform/remoteSettings.test.ts b/src/platform/remoteSettings.test.ts
index 86360e1a9..604b04af5 100644
--- a/src/platform/remoteSettings.test.ts
+++ b/src/platform/remoteSettings.test.ts
@@ -3,6 +3,7 @@ import { CLIENT_SETTINGS_KEYS } from "./clientSettings";
 import { commands, call, type Settings } from "./ipc";
 import { loadSettings, useProject } from "./project";
 import { connectRemote, disableRemote, enableRemote, isRemoteWindow, remoteRouting } from "./remote";
+import { invoke as routedInvoke } from "./tauriCore";
 
 const handlers = vi.hoisted(() => new Map<string, () => void>());
 vi.mock("./ipc", async (original) => ({
@@ -41,7 +42,13 @@ beforeEach(() => {
     cmd === "remote_invoke" ? JSON.stringify(remote) : local,
   );
   Object.assign(window, { __TAURI_INTERNALS__: { invoke, transformCallback: () => 1 } });
-  enableRemote({ sshConfig: "test", root: "/remote", host: "test", commands: [...served] });
+  enableRemote({
+    target: { kind: "ssh", config: "test" },
+    root: "/remote",
+    host: "test",
+    os: "linux",
+    commands: [...served],
+  });
 });
 afterEach(() => {
   disableRemote();
@@ -49,6 +56,33 @@ afterEach(() => {
 });
 
 describe("remote client settings", () => {
+  it.each([
+    { gradle: { dir: "app", projects: [] }, expected: [{ dir: "app", projects: [] }] },
+    {
+      gradle: [
+        { dir: "one", projects: [] },
+        { dir: "two", projects: [] },
+      ],
+      expected: [
+        { dir: "one", projects: [] },
+        { dir: "two", projects: [] },
+      ],
+    },
+    { gradle: null, expected: null },
+  ])("accepts the released and current remote Gradle build models: $gradle", async ({ gradle, expected }) => {
+    for (const command of ["build_model", "build_sync", "gradle_link_projects", "gradle_unlink_projects"]) {
+      enableRemote({
+        target: { kind: "wsl", distro: "Ubuntu" },
+        root: "/remote",
+        host: "Ubuntu",
+        os: "linux",
+        commands: [command],
+      });
+      invoke.mockResolvedValue(JSON.stringify({ gradle, maven: null }));
+      expect(await routedInvoke(command)).toEqual({ gradle: expected, maven: null });
+    }
+  });
+
   it("ends remote routing before a successful local open is published, even at the same path", async () => {
     invoke.mockResolvedValueOnce({ root: "/remote", settings: local });
     await call(commands.openProject("/remote"));
@@ -91,7 +125,7 @@ describe("remote client settings", () => {
     invoke.mockImplementation(async (cmd: string) =>
       cmd === "remote_connect"
         ? {
-            sshConfig: "test",
+            target: { kind: "ssh", config: "test" },
             root: "/remote",
             host: "test",
             commands: [...served],
@@ -101,7 +135,7 @@ describe("remote client settings", () => {
           ? "null"
           : local,
     );
-    await connectRemote("test", "/remote");
+    await connectRemote({ kind: "ssh", config: "test" }, "/remote");
     expect(useProject.getState().settings).toMatchObject({ keymap: "my-map", editor: { tabSize: 2, fontSize: 19 } });
   });
   it("overlays the project snapshot used by the settings window", async () => {
diff --git a/src/platform/reordered-tap-click.test.ts b/src/platform/reordered-tap-click.test.ts
index e415ac992..103ec26de 100644
--- a/src/platform/reordered-tap-click.test.ts
+++ b/src/platform/reordered-tap-click.test.ts
@@ -87,6 +87,35 @@ describe("installReorderedTapClick", () => {
     expect(log.filter((l) => l.startsWith("click"))).toEqual(["click:1", "click:1"]);
   });
 
+  it("leaves a quick double-click alone when its second press shares the first release's timestamp", () => {
+    // Fast input (automation, a quick double-click) stamps both at the same time step.
+    el.dispatchEvent(ev("pointerdown", 5900.9));
+    el.dispatchEvent(ev("mousedown", 5900.9, { detail: 1 }));
+    el.dispatchEvent(ev("pointerup", 5901));
+    el.dispatchEvent(ev("mouseup", 5901));
+    el.dispatchEvent(ev("click", 5901, { detail: 1 }));
+    el.dispatchEvent(ev("pointerdown", 5901));
+    el.dispatchEvent(ev("mousedown", 5901, { detail: 2 }));
+    el.dispatchEvent(ev("pointerup", 5901));
+    el.dispatchEvent(ev("mouseup", 5901));
+    el.dispatchEvent(ev("click", 5901, { detail: 2 }));
+    el.dispatchEvent(ev("dblclick", 5912, { detail: 2 }));
+    vi.runAllTimers();
+    expect(log.filter((l) => /^(click|dblclick)/.test(l))).toEqual(["click:1", "click:2", "dblclick:2"]);
+  });
+
+  it("finishes nothing when the engine releases the press before the tick", () => {
+    el.dispatchEvent(ev("pointerup", 1393));
+    el.dispatchEvent(ev("pointerdown", 1386));
+    el.dispatchEvent(ev("mousedown", 1386, { detail: 1 }));
+    el.dispatchEvent(ev("pointerup", 1400));
+    el.dispatchEvent(ev("mouseup", 1400));
+    el.dispatchEvent(ev("click", 1400, { detail: 1 }));
+    vi.runAllTimers();
+    expect(log.filter((l) => l.startsWith("click"))).toEqual(["click:1"]);
+    expect(log.filter((l) => l.startsWith("pointerup"))).toHaveLength(2);
+  });
+
   it("repeats the double-click detail of the stale press", () => {
     reversedTap(1393, 1386, 2);
     expect(log).toContain("click:2");
diff --git a/src/platform/reordered-tap-click.ts b/src/platform/reordered-tap-click.ts
index b2c2d048c..ac78e00d8 100644
--- a/src/platform/reordered-tap-click.ts
+++ b/src/platform/reordered-tap-click.ts
@@ -3,8 +3,8 @@
  * focus, and with a third-party input method it can hand the page a tap as `pointerup` ->
  * `pointerdown` (WebKit bug 219670). The press then has no release: the tap's click is lost,
  * and the engine, which still considers the button down, starts the next tap with a bare
- * `mousedown` (no `pointerdown`). `pointerdown.timeStamp` stays native, so a press stamped no
- * later than the `pointerup` just before it is a reordered tap: finish it with a synthetic
+ * `mousedown` (no `pointerdown`). `pointerdown.timeStamp` stays native, so a press stamped before
+ * the `pointerup` just before it is a reordered tap: finish it with a synthetic
  * `pointerup`/`mouseup`/`click`, and give the next press the `pointerdown` the engine skips.
  * The next tap's own click lands on its own target, so it is left alone.
  *
@@ -47,7 +47,10 @@ export function installReorderedTapClick({
   const onPointerUp = (e: PointerEvent) => {
     if (!isTrusted(e)) return;
     down = false;
-    if (primaryMouse(e)) lastUp = e.timeStamp;
+    if (!primaryMouse(e)) return;
+    lastUp = e.timeStamp;
+    // The engine released the press itself, so it was not a stale one: there is nothing to finish.
+    pending = null;
   };
 
   const onPointerCancel = (e: PointerEvent) => {
@@ -60,7 +63,8 @@ export function installReorderedTapClick({
     const before = lastUp;
     lastUp = null;
     pending = null;
-    if (!primaryMouse(e) || before === null || e.timeStamp > before) return;
+    // A quick in-order click can stamp its press with its last release's time: only an earlier press is stale.
+    if (!primaryMouse(e) || before === null || e.timeStamp >= before) return;
     if (!(e.target instanceof Element)) return;
     pending = { target: e.target, detail: 1, x: e.clientX, y: e.clientY, mods: mods(e) };
     // After this tick the page's own pointerdown/mousedown handlers have run, as for an in-order tap.
diff --git a/src/ui/Dialog.test.tsx b/src/ui/Dialog.test.tsx
index 7b5bef897..3a986495f 100644
--- a/src/ui/Dialog.test.tsx
+++ b/src/ui/Dialog.test.tsx
@@ -168,6 +168,21 @@ describe("Dialog chrome", () => {
     expect([dialog.style.width, dialog.style.height]).toEqual(["600px", "400px"]);
   });
 
+  it("caps a content-sized dialog at maxHeight until it is resized", () => {
+    render(
+      <Dialog open onClose={() => {}} title="Push" resizable="both" maxHeight={720}>
+        <div>rows</div>
+      </Dialog>,
+    );
+    const dialog = screen.getByRole("dialog");
+    expect(dialog.style.maxHeight).toBe("min(720px, 100%)");
+    fireEvent.pointerDown(screen.getByRole("separator", { name: "Resize" }), { button: 0, clientX: 0, clientY: 0 });
+    fireEvent.pointerMove(window, { buttons: 1, clientX: 500, clientY: 800 });
+    fireEvent.pointerUp(window);
+    expect(dialog.style.maxHeight).toBe("");
+    expect(dialog.style.height).not.toBe("");
+  });
+
   it("still drags a window dialog by its title bar", () => {
     render(
       <Dialog open onClose={() => {}} title="Usages Detected" buttons={safeDelete()} platform="other">
diff --git a/src/ui/Dialog.tsx b/src/ui/Dialog.tsx
index 940c6e90f..8c488a585 100644
--- a/src/ui/Dialog.tsx
+++ b/src/ui/Dialog.tsx
@@ -117,6 +117,8 @@ export interface DialogProps {
   resizable?: "both";
   minWidth?: number;
   minHeight?: number;
+  /** Height cap while content-sized; a manual resize lifts it. */
+  maxHeight?: number;
   /** Size to open at, such as one remembered from `onResized`; kept inside the window. */
   initialSize?: { w: number; h: number } | null;
   /** The size a resize ended at. */
@@ -210,6 +212,7 @@ function DialogInner({
   resizable,
   minWidth,
   minHeight,
+  maxHeight,
   initialSize,
   onResized,
   position = "center",
@@ -392,6 +395,7 @@ function DialogInner({
         style={{
           width: size ? size.w : width,
           height: size?.h,
+          maxHeight: !size && maxHeight ? `min(${maxHeight}px, 100%)` : undefined,
           translate: offset.x || offset.y ? `${offset.x}px ${offset.y}px` : undefined,
         }}
       >
diff --git a/src/ui/Select.tsx b/src/ui/Select.tsx
index 8d46fbe2e..2cb36e5d0 100644
--- a/src/ui/Select.tsx
+++ b/src/ui/Select.tsx
@@ -1,4 +1,4 @@
-import { useRef, useState, type KeyboardEvent, type ReactNode } from "react";
+import { useEffect, useRef, useState, type KeyboardEvent, type ReactNode } from "react";
 import clsx from "clsx";
 import { Icon, type IconName } from "./icons";
 import { Popup } from "./Popup";
@@ -33,6 +33,8 @@ export interface SelectProps<V extends string = string> {
   renderValue?: (option: SelectOption<V> | undefined) => ReactNode;
   /** Show a search box in the popup (useful for long option lists). */
   searchable?: boolean;
+  /** The option under the pointer or keyboard while the list is open; `null` once it closes. */
+  onPreview?: (value: V | null) => void;
 }
 
 const TYPE_AHEAD_MS = 800;
@@ -59,6 +61,7 @@ export function Select<V extends string = string>({
   className,
   renderValue,
   searchable = false,
+  onPreview,
   ...aria
 }: SelectProps<V>) {
   const tx = useTx();
@@ -112,6 +115,14 @@ export function Select<V extends string = string>({
   const activeIndex =
     filtered[active] && !unavailable(filtered[active]!) ? active : filtered.findIndex((o) => !unavailable(o));
 
+  const previewed = open ? (filtered[activeIndex]?.value ?? null) : null;
+  const lastPreview = useRef<V | null>(null);
+  useEffect(() => {
+    if (previewed === lastPreview.current) return;
+    lastPreview.current = previewed;
+    onPreview?.(previewed);
+  }, [previewed, onPreview]);
+
   const openPopup = () => {
     setQuery("");
     setActive(
diff --git a/src/ui/Tree.module.css b/src/ui/Tree.module.css
index 1ea24b8f4..e94759b2e 100644
--- a/src/ui/Tree.module.css
+++ b/src/ui/Tree.module.css
@@ -77,6 +77,15 @@
 .tree:focus-within .selected {
   background: var(--bg-tree-selected);
 }
+/* Adjacent selected rows merge into one rounded block. */
+.joinPrev {
+  border-top-left-radius: 0;
+  border-top-right-radius: 0;
+}
+.joinNext {
+  border-bottom-left-radius: 0;
+  border-bottom-right-radius: 0;
+}
 .tree:focus-visible .lead:not(.selected) {
   box-shadow: inset 0 0 0 1px color-mix(in srgb, var(--focus-ring) 50%, transparent);
 }
diff --git a/src/ui/Tree.tsx b/src/ui/Tree.tsx
index 5612f458c..84e5f0ceb 100644
--- a/src/ui/Tree.tsx
+++ b/src/ui/Tree.tsx
@@ -626,6 +626,10 @@ export function Tree<T>(props: TreeProps<T>) {
               );
             }
             const isSelected = selected.has(row.key);
+            const prevRow = rows[v.index - 1];
+            const nextRow = rows[v.index + 1];
+            const joinPrev = isSelected && !!prevRow && !prevRow.loading && selected.has(prevRow.key);
+            const joinNext = isSelected && !!nextRow && !nextRow.loading && selected.has(nextRow.key);
             const isLead = v.index === leadIndex;
             const matches = matchMap.get(row.key) ?? null;
             const state: TreeRowState = {
@@ -655,6 +659,8 @@ export function Tree<T>(props: TreeProps<T>) {
                   props.horizontalScroll && styles.wideRow,
                   rowClassName?.(row.node),
                   isSelected && styles.selected,
+                  joinPrev && styles.joinPrev,
+                  joinNext && styles.joinNext,
                   isLead && styles.lead,
                   reordering.drop?.key === row.key && styles[reordering.drop.position],
                 )}
diff --git a/src/ui/icons.tsx b/src/ui/icons.tsx
index 7caf73061..2de5f82c7 100644
--- a/src/ui/icons.tsx
+++ b/src/ui/icons.tsx
@@ -225,6 +225,8 @@ const ICONS = {
   refresh: "general/refresh",
   settings: "general/settings",
   help: "openidea/general/help",
+  "page-first": "openidea/general/pageFirst",
+  "page-last": "openidea/general/pageLast",
   sliders: "openidea/general/sliders",
   "graphql-variables": "openidea/general/graphqlVariables",
   layout: "general/layout",
@@ -349,6 +351,7 @@ const ICONS = {
   profile: "run/profile",
   "toolwindow-coverage": "toolwindows/coverage",
   "toolwindow-profiler": "toolwindows/profiler",
+  "toolwindow-logcat": "openidea/fileTypes/log",
   "gutter-run": "gutter/run",
   "gutter-run-all": "actions/runAll",
   "gutter-run-passed": "gutter/runSuccess",
@@ -359,6 +362,7 @@ const ICONS = {
   "gutter-overriding": "gutter/overridingMethod",
   stop: "run/stop",
   rerun: "run/rerun",
+  "hot-reload": "openidea/general/hotReload",
   "rerun-filled": "run/rerun_stroke",
   "restart-debug": "run/restartDebug",
   "restart-debug-filled": "run/restartDebug_stroke",
diff --git a/src/ui/openidea/general/hotReload.svg b/src/ui/openidea/general/hotReload.svg
new file mode 100644
index 000000000..909a103c9
--- /dev/null
+++ b/src/ui/openidea/general/hotReload.svg
@@ -0,0 +1,4 @@
+<!-- OpenIDEA: hot reload (a lightning bolt) in the expui style. -->
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M9.5 1.5L3.5 9H7.5L6.5 14.5L12.5 7H8.5L9.5 1.5Z" stroke="#6C707E" stroke-linejoin="round"/>
+</svg>
diff --git a/src/ui/openidea/general/pageFirst.svg b/src/ui/openidea/general/pageFirst.svg
new file mode 100644
index 000000000..d35844413
--- /dev/null
+++ b/src/ui/openidea/general/pageFirst.svg
@@ -0,0 +1,4 @@
+<!-- OpenIDEA: First Page (bar and chevron left) -->
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M4.5 4.5V11.5M11 11.5L7.5 8L11 4.5" stroke="#6C707E" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>
diff --git a/src/ui/openidea/general/pageLast.svg b/src/ui/openidea/general/pageLast.svg
new file mode 100644
index 000000000..6889b50a6
--- /dev/null
+++ b/src/ui/openidea/general/pageLast.svg
@@ -0,0 +1,4 @@
+<!-- OpenIDEA: Last Page (chevron right and bar) -->
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M11.5 4.5V11.5M5 11.5L8.5 8L5 4.5" stroke="#6C707E" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>
diff --git a/src/workbench/TitleBar.tsx b/src/workbench/TitleBar.tsx
index 3ac6a89a4..daf68e7d4 100644
--- a/src/workbench/TitleBar.tsx
+++ b/src/workbench/TitleBar.tsx
@@ -23,7 +23,7 @@ import {
 import { WindowControls } from "./WindowControls";
 import { usePlatform } from "@/platform/platformInfo";
 import { projectInitials } from "./projectColor";
-import { keymapItems, themeItems, VIEW_MODE_ITEMS } from "./quickSwitch";
+import { keymapItems, themeItems, themePreview, type ThemePreview, VIEW_MODE_ITEMS } from "./quickSwitch";
 import { useContributedThemes } from "@/platform/themes";
 import { currentThemeChoice, useThemeOverride } from "./theme";
 import styles from "./TitleBar.module.css";
@@ -147,13 +147,18 @@ export function customizeToolbarItems(
   ];
 }
 
-/** IDEA's main toolbar gear: Run Anything, Settings, Plugins, quick switches, toolbar customization, updates. */
+/**
+ * IDEA's main toolbar gear: Run Anything, Settings, Plugins, quick switches, toolbar customization, updates.
+ * With `preview`, a theme under the pointer shows as in Quick Switch.
+ */
 export function gearMenuItems(
   themeId: string,
   keymapId: string,
   customKeymaps: string[],
   customize: MenuItem[] = [{ kind: "action", action: "toolbar.customize", label: "Customize Toolbar…" }],
+  preview?: ThemePreview,
 ): MenuItem[] {
+  const restore = preview && (() => preview.restore());
   return [
     { kind: "action", action: "runAnything.show" },
     { kind: "separator" },
@@ -163,20 +168,25 @@ export function gearMenuItems(
     {
       id: "gear.theme",
       label: "Theme",
-      submenu: [...themeItems(themeId), { kind: "separator" }, { kind: "action", action: "settings.appearance" }],
+      submenu: [
+        ...themeItems(themeId, preview),
+        { kind: "separator" },
+        { kind: "action", action: "settings.appearance" },
+      ],
     },
     {
       id: "gear.keymap",
       label: "Keymap",
+      onActive: restore,
       submenu: [
         ...keymapItems(keymapId, customKeymaps),
         { kind: "separator" },
         { kind: "action", action: "settings.keymap", label: "Configure Keymap…" },
       ],
     },
-    { id: "gear.viewMode", label: "View Mode", submenu: VIEW_MODE_ITEMS },
+    { id: "gear.viewMode", label: "View Mode", onActive: restore, submenu: VIEW_MODE_ITEMS },
     { kind: "separator" },
-    { id: "gear.customizeToolbar", label: "Customize Main Toolbar", submenu: customize },
+    { id: "gear.customizeToolbar", label: "Customize Main Toolbar", onActive: restore, submenu: customize },
     { kind: "separator" },
     { kind: "action", action: "app.checkForUpdates" },
   ];
@@ -205,12 +215,20 @@ function GearButton({ customize }: { customize: MenuItem[] }) {
   const preset = useKeymap((s) => s.preset);
   const customs = settings?.customKeymaps;
   useContributedThemes((s) => s.themes);
+  // One preview per opening: a theme shown from it goes away with the menu unless chosen.
+  const preview = useMemo(() => (open ? themePreview() : undefined), [open]);
   const items = gearMenuItems(
     currentThemeChoice(),
     typeof settings?.keymap === "string" ? settings.keymap : preset,
     customs && typeof customs === "object" ? Object.keys(customs) : [],
     customize,
+    preview,
   );
+  const close = () => {
+    setOpen(false);
+    // A chosen theme runs right after the menu closes: let it choose first.
+    queueMicrotask(() => preview?.end());
+  };
   return (
     <>
       <IconButton
@@ -221,15 +239,9 @@ function GearButton({ customize }: { customize: MenuItem[] }) {
         className={styles.tool}
         aria-haspopup="menu"
         aria-expanded={open}
-        onClick={() => setOpen((v) => !v)}
-      />
-      <Menu
-        open={open}
-        onClose={() => setOpen(false)}
-        anchor={ref}
-        items={items}
-        aria-label="IDE and Project Settings"
+        onClick={() => (open ? close() : setOpen(true))}
       />
+      <Menu open={open} onClose={close} anchor={ref} items={items} aria-label="IDE and Project Settings" />
     </>
   );
 }
diff --git a/src/workbench/confirmTerminate.ts b/src/workbench/confirmTerminate.ts
new file mode 100644
index 000000000..0838fe9b6
--- /dev/null
+++ b/src/workbench/confirmTerminate.ts
@@ -0,0 +1,26 @@
+import { tx } from "@/platform/i18n";
+import { call, commands, isTauri } from "@/platform/ipc";
+import { loadSettings } from "@/platform/project";
+import { confirmChecked } from "./messages";
+
+/**
+ * IDEA's question before closing a Run or Debug tab whose process still runs (asked while
+ * `run.confirmTerminate` is on). Resolves true for Terminate.
+ */
+export async function confirmTerminate(name: string): Promise<boolean> {
+  const answer = await confirmChecked({
+    title: tx`Process '${name}' Is Running`,
+    message: tx`Do you want to terminate the process '${name}'?`,
+    ok: "Terminate",
+    checkbox: "Do not ask again",
+  });
+  if (answer?.checked && isTauri()) {
+    try {
+      await call(commands.settingsSet("global", "run.confirmTerminate", "false"));
+      await loadSettings();
+    } catch {
+      /* keep asking */
+    }
+  }
+  return answer !== null;
+}
diff --git a/src/workbench/contributions.ts b/src/workbench/contributions.ts
index 7b7c2a633..8f09062c8 100644
--- a/src/workbench/contributions.ts
+++ b/src/workbench/contributions.ts
@@ -1459,6 +1459,42 @@ export const useDebugRunSessions = create<{
   Console: ComponentType<{ sessionId: number }> | null;
 }>(() => ({ sessions: [], serviceSessions: [], Console: null }));
 
+// ---------------------------------------------------------------------------
+// Processes a closing window or project would terminate. Features that own
+// child processes (Run/Debug sessions) publish them here, so the close guard can
+// ask first (IDEA's "Terminate processes?").
+
+export interface RunningProcess {
+  /** Configuration or session name shown in the prompt. */
+  name: string;
+}
+
+export interface RunningProcessesProvider {
+  id: string;
+  /** Processes this feature is running in the window right now. */
+  running(): RunningProcess[] | Promise<RunningProcess[]>;
+}
+
+const runningProcessesProviders = new Map<string, RunningProcessesProvider>();
+
+export function registerRunningProcessesProvider(p: RunningProcessesProvider): () => void {
+  runningProcessesProviders.set(p.id, p);
+  return () => {
+    if (runningProcessesProviders.get(p.id) === p) runningProcessesProviders.delete(p.id);
+  };
+}
+
+/** Live processes of every provider, one entry per name. */
+export async function runningProcesses(): Promise<RunningProcess[]> {
+  const all = (await Promise.all([...runningProcessesProviders.values()].map((p) => p.running()))).flat();
+  const seen = new Set<string>();
+  return all.filter((p) => {
+    if (!p.name || seen.has(p.name)) return false;
+    seen.add(p.name);
+    return true;
+  });
+}
+
 // ---------------------------------------------------------------------------
 // "Get from Version Control" sources besides a plain URL (IDEA: GitHub, GitLab…),
 // listed in the Clone Repository dialog's sidebar.
diff --git a/src/workbench/projectWindow.ts b/src/workbench/projectWindow.ts
index a64c8b139..a80c05a36 100644
--- a/src/workbench/projectWindow.ts
+++ b/src/workbench/projectWindow.ts
@@ -1,6 +1,6 @@
 /** Where a project opens when this window already has one: System Settings › Project › "Open project in". */
 import { t } from "@/platform/i18n";
-import { call, commands } from "@/platform/ipc";
+import { call, commands, type RemoteTarget } from "@/platform/ipc";
 import { confirmLeaveProject, useProject } from "@/platform/project";
 import { connectRemote, isRemoteWindow } from "@/platform/remote";
 import { ask } from "./messages";
@@ -50,20 +50,20 @@ export async function chooseProjectWindow(name: string, allowAttach = true): Pro
 }
 
 /**
- * Opens folder `path` on the host of SSH configuration `sshConfig`: focuses the
+ * Opens folder `path` of `target` (an SSH host or a WSL distribution): focuses the
  * window that has it, else opens it in a new window or (`here`) this one per
  * "Open project in". `false`: cancelled.
  */
 export async function openRemoteProject(
-  sshConfig: string,
+  target: RemoteTarget,
   path: string,
-  here: () => Promise<unknown> = () => connectRemote(sshConfig, path),
+  here: () => Promise<unknown> = () => connectRemote(target, path),
 ): Promise<boolean> {
-  if ((await call(commands.windowOpenRemote(sshConfig, path, false))).kind === "focused") return true;
+  if ((await call(commands.windowOpenRemote(target, path, false))).kind === "focused") return true;
   const mode = await chooseProjectWindow(path.replace(/\/+$/, "").split("/").pop() || path, false);
   if (!mode) return false;
   if (mode === "new") {
-    await call(commands.windowOpenRemote(sshConfig, path, true));
+    await call(commands.windowOpenRemote(target, path, true));
     return true;
   }
   if (!(await confirmLeaveProject())) return false;
diff --git a/src/workbench/runningProcesses.test.ts b/src/workbench/runningProcesses.test.ts
new file mode 100644
index 000000000..8a53c7b22
--- /dev/null
+++ b/src/workbench/runningProcesses.test.ts
@@ -0,0 +1,35 @@
+import { expect, it, vi } from "vitest";
+import { registerRunningProcessesProvider, runningProcesses } from "./contributions";
+
+it("collects live processes from every provider, one entry per name", async () => {
+  const first = vi.fn(async () => [{ name: "app" }, { name: "worker" }]);
+  const second = vi.fn(() => [{ name: "app" }, { name: "docs" }]);
+  const disposers = [
+    registerRunningProcessesProvider({ id: "test.first", running: first }),
+    registerRunningProcessesProvider({ id: "test.second", running: second }),
+  ];
+  try {
+    expect(await runningProcesses()).toEqual([{ name: "app" }, { name: "worker" }, { name: "docs" }]);
+    expect(first).toHaveBeenCalledOnce();
+    expect(second).toHaveBeenCalledOnce();
+  } finally {
+    disposers.forEach((dispose) => dispose());
+  }
+  expect(await runningProcesses()).toEqual([]);
+});
+
+it("keeps a replacement provider registered when its predecessor is disposed", async () => {
+  const disposeOld = registerRunningProcessesProvider({ id: "test.replaced", running: async () => [] });
+  const disposeNew = registerRunningProcessesProvider({
+    id: "test.replaced",
+    running: async () => [{ name: "app" }],
+  });
+  try {
+    disposeOld();
+    expect(await runningProcesses()).toEqual([{ name: "app" }]);
+  } finally {
+    disposeOld();
+    disposeNew();
+  }
+  expect(await runningProcesses()).toEqual([]);
+});
diff --git a/src/workbench/theme.ts b/src/workbench/theme.ts
index e4559ad33..128edd2cc 100644
--- a/src/workbench/theme.ts
+++ b/src/workbench/theme.ts
@@ -218,7 +218,12 @@ export function currentThemeChoice(): ThemeChoiceId {
     : resolveThemeChoice(useProject.getState().settings?.appearance as AppearanceLike | undefined, prefersLight());
 }
 
+/** A previewed theme is not the next start-up's (`rememberStartupTheme`). */
+let previewing = false;
+
 export async function setTheme(next: ThemeSetting) {
+  // A theme chosen while previewed is the next start-up's.
+  previewing = false;
   useThemeOverride.setState({ theme: next });
   if (!isTauri()) return;
   try {
@@ -233,9 +238,6 @@ export async function setTheme(next: ThemeSetting) {
   }
 }
 
-/** A previewed theme is not the next start-up's (`rememberStartupTheme`). */
-let previewing = false;
-
 /**
  * Shows `id` in this window without selecting it (Quick Switch's instant
  * theme switch); `null` shows the selected theme again. Nothing is saved and
diff --git a/wit/events.wit b/wit/events.wit
index 2d118d812..7da95eac5 100644
--- a/wit/events.wit
+++ b/wit/events.wit
@@ -1,4 +1,4 @@
-package openidea:plugin@1.0.0;
+package openidea:plugin@1.1.0;
 
 /// Workbench events, delivered in batches to `event-handler.handle`.
 interface events {
diff --git a/wit/exports.wit b/wit/exports.wit
index 065ef9a5f..808377432 100644
--- a/wit/exports.wit
+++ b/wit/exports.wit
@@ -1,4 +1,4 @@
-package openidea:plugin@1.0.0;
+package openidea:plugin@1.1.0;
 
 interface lifecycle {
     use types.{context, error};
diff --git a/wit/host.wit b/wit/host.wit
index b6325cb71..c7ac7f916 100644
--- a/wit/host.wit
+++ b/wit/host.wit
@@ -1,4 +1,4 @@
-package openidea:plugin@1.0.0;
+package openidea:plugin@1.1.0;
 
 /// Writes to the IDE log, tagged with the plugin id.
 interface log {
@@ -8,7 +8,7 @@ interface log {
 }
 
 interface ui {
-    use types.{notification-level};
+    use types.{error, notification-level};
 
     record status-item {
         text: string,
@@ -23,6 +23,10 @@ interface ui {
     /// Shows or updates the plugin's status bar item `id` in every window.
     set-status-item: func(id: string, item: status-item);
     remove-status-item: func(id: string);
+    /// Copies `text` to the system clipboard. Requires `clipboard`.
+    copy-to-clipboard: func(text: string) -> result<_, error>;
+    /// Opens an `http://` or `https://` URL in the user's default browser.
+    open-url: func(url: string) -> result<_, error>;
 }
 
 /// Persistent key-value storage of the plugin (survives restarts and idle
diff --git a/wit/io.wit b/wit/io.wit
index f1fe634a3..b93ea079e 100644
--- a/wit/io.wit
+++ b/wit/io.wit
@@ -1,4 +1,4 @@
-package openidea:plugin@1.0.0;
+package openidea:plugin@1.1.0;
 
 /// Problems in files, shown in the editor and the Problems view.
 interface diagnostics {
diff --git a/wit/plugin.wit b/wit/plugin.wit
index 938ee0842..e9fc0ac85 100644
--- a/wit/plugin.wit
+++ b/wit/plugin.wit
@@ -7,7 +7,7 @@
 /// or processes beyond WASI's clocks and randomness; everything else goes
 /// through the imports below, gated by the capabilities granted in
 /// `plugin.toml` (a missing one returns `error::denied`).
-package openidea:plugin@1.0.0;
+package openidea:plugin@1.1.0;
 
 world plugin {
     import log;
diff --git a/wit/providers.wit b/wit/providers.wit
index 97dd4c7a6..17c1123a8 100644
--- a/wit/providers.wit
+++ b/wit/providers.wit
@@ -1,4 +1,4 @@
-package openidea:plugin@1.0.0;
+package openidea:plugin@1.1.0;
 
 /// Editor features a plugin provides for the languages it declares under
 /// `[[contributes.providers]]` (the host calls only declared kinds). They run
diff --git a/wit/types.wit b/wit/types.wit
index 2e2b48f74..de35cadf6 100644
--- a/wit/types.wit
+++ b/wit/types.wit
@@ -1,4 +1,4 @@
-package openidea:plugin@1.0.0;
+package openidea:plugin@1.1.0;
 
 /// Shared types. Positions are 0-based lines and UTF-16 code unit columns,
 /// as in the editor and LSP.
diff --git a/wit/views.wit b/wit/views.wit
index c4435eced..8a67e222e 100644
--- a/wit/views.wit
+++ b/wit/views.wit
@@ -1,4 +1,4 @@
-package openidea:plugin@1.0.0;
+package openidea:plugin@1.1.0;
 
 /// Declarative views: tool windows declared
 /// under `[[contributes.views]]` and custom editors under
diff --git a/wit/workspace.wit b/wit/workspace.wit
index febca7c6f..180040471 100644
--- a/wit/workspace.wit
+++ b/wit/workspace.wit
@@ -1,4 +1,4 @@
-package openidea:plugin@1.0.0;
+package openidea:plugin@1.1.0;
 
 interface workspace {
     use types.{error};
@@ -84,6 +84,8 @@ interface vcs {
 
     /// `none` when the project is not in a repository. Requires `vcs.read`.
     status: func(project: borrow<project>) -> result<option<repository-status>, error>;
+    /// Configured remotes (`name`, fetch `url`), in order. Requires `vcs.read`.
+    remotes: func(project: borrow<project>) -> result<list<tuple<string, string>>, error>;
     /// Fetches all remotes (pruning deleted branches). Requires `vcs.write`.
     /// Long-running: call it inside a task.
     fetch: func(project: borrow<project>) -> result<_, error>;