fix(vcs): let Commit and Shelf tree names use the whole row width

File and folder names in the Commit tool window's changes tree (and the Shelf tree, which shares the styles) were capped at 75% of the row, so a long folder name was cut with an ellipsis while a quarter of the row stayed empty, and the gap grew as the window widened. The name now takes the whole row; when it does not fit, the grey detail after it (the path or file count) is truncated first. Stash rows keep their previous shrinking.

Fixes #1367

.github/pull_request_template.md

@@ -1,4 +1,4 @@
-Closes #
+<!-- If this resolves an issue: Closes #<n> -->
 
 ## What and why
 

.github/workflows/ci.yml

@@ -71,6 +71,57 @@ jobs:
       - run: cargo build --locked -p ide-host --bin openidea-server --target x86_64-unknown-linux-musl
       - run: target/x86_64-unknown-linux-musl/debug/openidea-server --version
 
+  # The plugin SDK, the official plugins and the test fixtures build in their
+  # own workspaces (the root excludes them), so the jobs above don't see them.
+  plugins:
+    name: Plugins (SDK, official, fixtures)
+    runs-on: ubuntu-22.04
+    env:
+      CARGO_TARGET_DIR: ${{ github.workspace }}/target-plugins
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with: { targets: wasm32-wasip2, components: "clippy, rustfmt" }
+      - uses: Swatinem/rust-cache@v2
+        with:
+          key: plugins
+          cache-directories: target-plugins
+          save-if: ${{ github.ref == 'refs/heads/main' }}
+      - name: Format, lint (host and wasm) and test each crate
+        shell: bash
+        run: |
+          set -euo pipefail
+          for dir in sdk/rust/openidea-plugin plugins/official/*/ crates/ide-plugin/tests/fixtures/*/; do
+            [ -f "$dir/Cargo.toml" ] || continue
+            echo "::group::$dir"
+            cargo fmt --check --manifest-path "$dir/Cargo.toml"
+            cargo clippy --locked --all-targets --manifest-path "$dir/Cargo.toml" -- -D warnings
+            cargo clippy --locked --target wasm32-wasip2 --manifest-path "$dir/Cargo.toml" -- -D warnings
+            cargo test --locked --manifest-path "$dir/Cargo.toml"
+            echo "::endgroup::"
+          done
+      - uses: pnpm/action-setup@v4
+        with: { version: 11 }
+      - uses: actions/setup-node@v4
+        with: { node-version: 22 }
+      # Plugin web pages (`web-src/`, their own pnpm projects): typecheck and test.
+      - name: Web pages typecheck and test
+        shell: bash
+        run: |
+          set -euo pipefail
+          for dir in plugins/official/*/web-src/; do
+            [ -f "$dir/package.json" ] || continue
+            echo "::group::$dir"
+            pnpm --dir "$dir" install --frozen-lockfile --ignore-workspace
+            pnpm --dir "$dir" exec tsc --noEmit
+            pnpm --dir "$dir" test
+            echo "::endgroup::"
+          done
+      # The host's tests run the checked-in components: they must be built from these sources.
+      # Web pages aren't checked in: this builds them and checks the result.
+      - name: Checked-in components are up to date, web pages build
+        run: plugins/build.sh --check
+
   deny:
     name: Cargo deny
     runs-on: ubuntu-latest

.github/workflows/language-smoke.yml

@@ -0,0 +1,110 @@
+name: Language smoke
+# Everyday code intelligence (completion, go to definition, Find Usages, hover, diagnostics
+# with a quick fix, an intention, formatting, rename) per language, against the language
+# server the app starts by default: crates/ide-host/tests/language_smoke.rs.
+# Then running and testing each fixture through the run store and openidea-server
+# (Run, Run tests, the test tree, Rerun Failed Tests): smoke/run.test.ts.
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+    types: [opened, synchronize, reopened]
+    paths:
+      - "crates/**"
+      - "languages/**"
+      - "fixtures/**"
+      - "Cargo.toml"
+      - "Cargo.lock"
+      - "src/features/run/**"
+      - "src/platform/**"
+      - "smoke/**"
+      - "package.json"
+      - "pnpm-lock.yaml"
+      - ".github/workflows/language-smoke.yml"
+  workflow_dispatch:
+
+concurrency:
+  group: language-smoke-${{ github.ref }}
+  # A new push supersedes a PR's run; on main every merge runs to the end (and saves the cache).
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+env:
+  CARGO_TERM_COLOR: always
+  CARGO_INCREMENTAL: 0
+  # Pinned so a server release can't fail an unrelated PR; bump them deliberately.
+  VTSLS: 0.3.0
+  TYPESCRIPT: 6.0.3
+  BASEDPYRIGHT: 1.40.2
+  RUFF: 0.17.3
+  GOPLS: v0.24.0
+  JDTLS: 1.63.0-202610191322
+  KOTLIN_LSP: 263.7084.0
+  GRADLE: 8.14.3
+
+jobs:
+  smoke:
+    name: Language smoke (${{ matrix.language }})
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [typescript, python, rust, go, java, kotlin]
+    runs-on: ubuntu-22.04
+    timeout-minutes: 40
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with: { components: "rust-analyzer, rustfmt" }
+      # One build cache for every language; main saves it.
+      - uses: Swatinem/rust-cache@v2
+        with:
+          shared-key: language-smoke
+          save-if: ${{ github.ref == 'refs/heads/main' && matrix.language == 'rust' }}
+
+      - uses: pnpm/action-setup@v4
+        with: { version: 11 }
+      - uses: actions/setup-node@v4
+        with: { node-version: 22, cache: pnpm }
+      - if: matrix.language == 'typescript'
+        run: npm install --global "@vtsls/language-server@$VTSLS" "typescript@$TYPESCRIPT"
+
+      - if: matrix.language == 'python'
+        uses: actions/setup-python@v5
+        with: { python-version: "3.12" }
+      - if: matrix.language == 'python'
+        run: pip install "basedpyright==$BASEDPYRIGHT" "ruff==$RUFF"
+
+      - if: matrix.language == 'go'
+        uses: actions/setup-go@v5
+        with: { go-version: "1.27", cache: false }
+      - if: matrix.language == 'go'
+        run: go install "golang.org/x/tools/gopls@$GOPLS"
+
+      - if: matrix.language == 'java' || matrix.language == 'kotlin'
+        uses: actions/setup-java@v4
+        with: { distribution: temurin, java-version: "21" }
+      - if: matrix.language == 'java'
+        run: |
+          mkdir -p "$RUNNER_TEMP/jdtls"
+          curl -fsSL "https://download.eclipse.org/jdtls/milestones/${JDTLS%-*}/jdt-language-server-$JDTLS.tar.gz" \
+            | tar xz -C "$RUNNER_TEMP/jdtls"
+          echo "$RUNNER_TEMP/jdtls/bin" >> "$GITHUB_PATH"
+
+      # The Kotlin fixture has no Gradle wrapper: the server imports it with the Gradle on PATH.
+      - if: matrix.language == 'kotlin'
+        uses: gradle/actions/setup-gradle@v4
+        with: { gradle-version: "${{ env.GRADLE }}" }
+      - if: matrix.language == 'kotlin'
+        run: |
+          mkdir -p "$RUNNER_TEMP/kotlin-lsp" "$RUNNER_TEMP/bin"
+          curl -fsSL "https://download.jetbrains.com/language-server/kotlin-server/$KOTLIN_LSP/kotlin-server-$KOTLIN_LSP.tar.gz" \
+            | tar xz -C "$RUNNER_TEMP/kotlin-lsp" --strip-components=1
+          ln -s "$RUNNER_TEMP/kotlin-lsp/kotlin-lsp.sh" "$RUNNER_TEMP/bin/kotlin-lsp"
+          echo "$RUNNER_TEMP/bin" >> "$GITHUB_PATH"
+
+      - run: cargo test --locked -p ide-host --test language_smoke --no-run
+      - run: cargo test --locked -p ide-host --test language_smoke -- --ignored --exact ${{ matrix.language }}
+
+      - run: pnpm install --frozen-lockfile
+      - run: cargo build --locked -p ide-host --bin openidea-server
+      - run: pnpm smoke smoke/run.test.ts -t "^${{ matrix.language }}$"

.github/workflows/plugins-index.yml

@@ -0,0 +1,46 @@
+name: Plugin index
+
+# Refreshes the community plugins in the latest release's plugins-index.json
+# (what released apps read) from the registry, l0ng-ai/openidea-plugins. The
+# official plugins, their key and revocations stay as the release wrote them.
+on:
+  schedule:
+    - cron: "17 * * * *"
+  workflow_dispatch:
+  # Sent by the registry when its index changes.
+  repository_dispatch:
+    types: [community-plugins]
+
+permissions:
+  contents: write
+
+concurrency:
+  group: plugins-index
+
+env:
+  COMMUNITY_PLUGINS_INDEX: https://github.com/l0ng-ai/openidea-plugins/releases/download/index/index.json
+
+jobs:
+  merge:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Merge the community index
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          set -euo pipefail
+          cd "$RUNNER_TEMP"
+          tag="$(gh release view --repo "$GITHUB_REPOSITORY" --json tagName -q .tagName)"
+          tool=openidea-plugin-linux-x86_64
+          if ! gh release download "$tag" --repo "$GITHUB_REPOSITORY" -p plugins-index.json -p "$tool.gz"; then
+            echo "::notice::$tag has no plugin index or openidea-plugin tool yet"
+            exit 0
+          fi
+          gunzip "$tool.gz" && chmod +x "$tool"
+          cp plugins-index.json before.json
+          "./$tool" merge plugins-index.json "$COMMUNITY_PLUGINS_INDEX" --keep openidea
+          if cmp -s before.json plugins-index.json; then
+            echo "unchanged"
+          else
+            gh release upload "$tag" plugins-index.json --repo "$GITHUB_REPOSITORY" --clobber
+          fi

.github/workflows/pr-check.yml

@@ -24,18 +24,9 @@ jobs:
             const pr = context.payload.pull_request;
             const LABEL = 'needs-info';
             const MARKER = '<!-- pr-check -->';
-            // Docs, CI and pure refactors may skip the linked issue.
-            const NO_ISSUE_TYPES = /^(docs|ci|build|chore|refactor|style|test)(\(.+\))?!?:/;
-
             const body = (pr.body || '').replace(/<!--[\s\S]*?-->/g, '');
             const problems = [];
 
-            const linksIssue =
-              /\b(close[sd]?|fix(e[sd])?|resolve[sd]?)\s*:?\s+(#\d+|https:\/\/github\.com\/[\w.-]+\/[\w.-]+\/issues\/\d+)/i.test(body);
-            if (!linksIssue && !NO_ISSUE_TYPES.test(pr.title)) {
-              problems.push('Link the issue this PR resolves, e.g. `Closes #123`.');
-            }
-
             const verified = body.match(/^##+\s*How it was verified\s*$([\s\S]*?)(?=^##+\s|(?![\s\S]))/im);
             if (!verified || !verified[1].trim()) {
               problems.push('Fill in **How it was verified**: the commands you ran and their results. UI changes need before/after screenshots.');

.github/workflows/release.yml

@@ -18,6 +18,7 @@ env:
   CARGO_TERM_COLOR: always
   CARGO_INCREMENTAL: 0
   TAG: ${{ github.event.inputs.tag || github.ref_name }}
+  COMMUNITY_PLUGINS_INDEX: https://github.com/l0ng-ai/openidea-plugins/releases/download/index/index.json
 
 jobs:
   # Creates (or reuses) one draft release that every platform build uploads into.
@@ -25,6 +26,7 @@ jobs:
     runs-on: ubuntu-latest
     outputs:
       release_id: ${{ steps.release.outputs.id }}
+      official_plugin_keys: ${{ steps.plugin-keys.outputs.keys }}
     steps:
       - uses: actions/checkout@v4
         with: { ref: "${{ env.TAG }}" }
@@ -35,6 +37,20 @@ jobs:
             echo "::error::tag $TAG does not match tauri.conf.json version $app"
             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
+      # the secret the app takes the index's word, as development builds do.
+      - id: plugin-keys
+        env:
+          SIGNING_KEY: ${{ secrets.PLUGIN_SIGNING_KEY }}
+        run: |
+          if [ -n "$SIGNING_KEY" ]; then
+            seed="$(printf %s "$SIGNING_KEY" | base64 -d | od -An -tx1 | tr -d ' \n')"
+            key="$(printf '302e020100300506032b657004220420%s' "$seed" | xxd -r -p |
+              openssl pkey -inform DER -pubout -outform DER | tail -c 32 | base64)"
+            echo "keys=$key" >> "$GITHUB_OUTPUT"
+          fi
       - id: release
         uses: actions/github-script@v7
         with:
@@ -57,6 +73,8 @@ jobs:
   build:
     needs: create-release
     name: Build (${{ matrix.name }})
+    env:
+      OPENIDEA_OFFICIAL_PLUGIN_KEYS: ${{ needs.create-release.outputs.official_plugin_keys }}
     strategy:
       fail-fast: false
       matrix:
@@ -180,6 +198,79 @@ jobs:
           if command -v sha256sum >/dev/null; then sha256sum "$ASSET"; else shasum -a 256 "$ASSET"; fi > "$ASSET.sha256"
           gh release upload "$TAG" "$ASSET" "$ASSET.sha256" --clobber
 
+  # The official plugins, signed, and the marketplace index released apps read
+  # (releases/latest/download/plugins-index.json). They are not in the
+  # installers: users install them from Settings › Plugins. Without the
+  # signing key (secret PLUGIN_SIGNING_KEY: the file `openidea-plugin keygen`
+  # writes) nothing is published and the release goes on. The index also lists
+  # the community plugins of the registry (COMMUNITY_PLUGINS_INDEX; refreshed
+  # between releases by plugins-index.yml), and the release carries the
+  # openidea-plugin tool for Linux x64, which that workflow and the registry's
+  # checks run.
+  plugins:
+    needs: create-release
+    name: Official plugins
+    runs-on: ubuntu-22.04
+    env:
+      SIGNING_KEY: ${{ secrets.PLUGIN_SIGNING_KEY }}
+    steps:
+      - id: key
+        run: |
+          if [ -z "$SIGNING_KEY" ]; then
+            echo "::warning::PLUGIN_SIGNING_KEY is not set: the official plugins are not published"
+            echo "skip=true" >> "$GITHUB_OUTPUT"
+          fi
+      - uses: actions/checkout@v4
+        if: steps.key.outputs.skip != 'true'
+        with: { ref: "${{ env.TAG }}" }
+      - uses: dtolnay/rust-toolchain@stable
+        if: steps.key.outputs.skip != 'true'
+        with: { targets: wasm32-wasip2 }
+      - uses: Swatinem/rust-cache@v2
+        if: steps.key.outputs.skip != 'true'
+        with: { key: release-plugins }
+      - uses: pnpm/action-setup@v4
+        if: steps.key.outputs.skip != 'true'
+        with: { version: 11 }
+      - uses: actions/setup-node@v4
+        if: steps.key.outputs.skip != 'true'
+        with: { node-version: 22 }
+      # Builds the web pages; fails when a checked-in component isn't built from these sources.
+      - name: Build
+        if: steps.key.outputs.skip != 'true'
+        run: |
+          plugins/build.sh --check
+          cargo build --release --locked -p ide-host --bin openidea-plugin
+      - name: Pack, index and upload
+        if: steps.key.outputs.skip != 'true'
+        shell: bash
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          set -euo pipefail
+          tool="$PWD/target/release/openidea-plugin"
+          key="$RUNNER_TEMP/openidea.key"
+          out="$RUNNER_TEMP/market"
+          (umask 077 && printf '%s' "$SIGNING_KEY" > "$key")
+          trap 'rm -f "$key"' EXIT
+          mkdir -p "$out"
+          for dir in plugins/official/*/; do
+            id="$(sed -n 's/^id *= *"\(.*\)".*/\1/p' "$dir/plugin.toml" | head -1)"
+            version="$(sed -n 's/^version *= *"\(.*\)".*/\1/p' "$dir/plugin.toml" | head -1)"
+            "$tool" pack "$dir" --key "$key" --publisher openidea --out "$out/$id-$version.oiplugin"
+          done
+          # The published index's revocations, earlier keys and community plugins carry over.
+          curl -fsSL "https://github.com/$GITHUB_REPOSITORY/releases/latest/download/plugins-index.json" \
+            -o "$out/plugins-index.json" || rm -f "$out/plugins-index.json"
+          # Downloads point at this release: older versions kept for older IDEs stay where they were published.
+          "$tool" index "$out" --publisher openidea --name OpenIDEA --key "$key" --out "$out/plugins-index.json" \
+            --download-base "https://github.com/$GITHUB_REPOSITORY/releases/download/$TAG"
+          "$tool" merge "$out/plugins-index.json" "$COMMUNITY_PLUGINS_INDEX" --keep openidea ||
+            echo "::warning::the community plugins were not refreshed"
+          gzip -9 -c "$tool" > "$out/openidea-plugin-linux-x86_64.gz"
+          gh release upload "$TAG" "$out"/*.oiplugin "$out/plugins-index.json" \
+            "$out/openidea-plugin-linux-x86_64.gz" --clobber
+
   # The updater manifest (latest.json), built once from the signed bundles every build uploaded.
   # Fails when a platform is missing, so a release never ships a manifest without it.
   updater-manifest:
@@ -243,7 +334,7 @@ jobs:
             core.info(`latest.json: ${Object.keys(platforms).sort().join(", ")}`);
 
   publish:
-    needs: [create-release, build, server, updater-manifest]
+    needs: [create-release, build, server, plugins, updater-manifest]
     runs-on: ubuntu-latest
     steps:
       - uses: actions/github-script@v7

.gitignore

@@ -10,6 +10,9 @@ lerna-debug.log*
 node_modules
 dist
 dist-ssr
+# Plugin components are checked in (plugins/build.sh --check keeps them current).
+!plugins/official/*/dist
+!crates/ide-plugin/tests/fixtures/*/dist
 *.local
 
 # Editor directories and files

.oxfmtrc.json

@@ -15,6 +15,8 @@
     "pnpm-lock.yaml",
     "**/*.toml",
     "fixtures",
+    "plugins/*/web",
+    "plugins/official/*/web",
     "crates/**/tests/fixtures"
   ],
   "overrides": [

AGENTS.md

@@ -18,9 +18,12 @@ Visual style: dark, low-contrast greys, one cool accent
 - `src/ui/` — design-system primitives. `src/features/<name>/` — one feature each,
   exporting `activate()` registered in `src/features/index.ts`.
 - `languages/<id>.toml` — language definitions (detection, comments, LSP, DAP).
-- `crates/ide-host` — the `openidea-server` binary for remote development.
-- `wit/` — plugin interface definitions; `plugins/` — sample and bundled plugins;
-  `templates/` — plugin starter templates.
+- `crates/ide-host` — the `openidea-server` binary for remote development and the
+  `openidea-plugin` CLI (plugin starter templates live in its `templates.rs`).
+- `wit/` — plugin interface definitions; `plugins/` — sample and bundled plugins.
+  Plugin docs: `plugins/README.md`, `docs/plugins/themes.md`.
+- `java/` — JDT LS extension bundles (`java-usages`, `kotlin-bridge`) and the patched
+  Lombok agent, embedded into the app by `ide-sdk` / `ide-tools`.
 - `e2e/` — Playwright UI tests (`pnpm e2e`). `fixtures/` — sample projects per language
   for manual and automated testing.
 
@@ -39,14 +42,15 @@ Visual style: dark, low-contrast greys, one cool accent
   icons from `src/ui/icons.tsx`, never emoji. Real `<button>`/`<input>`; `aria-label` on icon buttons.
 - User-visible text goes through the text catalog: add every new string to both
   `src/platform/locales/text/en.json` and `zh.json` (`textCatalog.test.ts` enforces it).
+  Other locales may lack entries; their UI shows the English text until a translator adds it.
 - Keep comments sparse and purposeful; match surrounding style.
 - For GUI verification, prefer Tauri MCP; use Computer Use only when Tauri MCP is
   unavailable or cannot cover the required checks.
 
 ## Issues & PRs
 
-Follow `CONTRIBUTING.md` and `.github/pull_request_template.md`: one issue per PR with
-`Closes #<n>`, reproduce first, keep the diff focused, short plain description, and a
+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.
 Unclear product decisions → `needs-decision` and stop.
 
@@ -63,6 +67,10 @@ Shared agent skills live in `.agents/skills/` (`.claude/skills/` links to them):
   this worktree's running MCP bridges and actual ports.
 - `pnpm build` — typecheck + bundle frontend.
 - `cargo nextest run --workspace` (or `cargo test`), `cargo clippy --workspace --all-targets -- -D warnings`, `cargo fmt --all`.
+- `cargo test -p ide-host --test language_smoke -- --ignored --exact <language>` — code intelligence
+  on `fixtures/` with that language's real server installed (CI: `Language smoke`, pinned versions).
+- `pnpm smoke smoke/run.test.ts -t <language>` — run and test that language's fixture through the
+  run store and a real `openidea-server` (build it first: `cargo build -p ide-host --bin openidea-server`).
 - `pnpm test`, `pnpm e2e`, `pnpm lint`, `pnpm format:check`, `pnpm knip`, `pnpm typecheck`,
   `pnpm gen:bindings`.
 - `pnpm perf` (UI interaction latency / frames / leaks), `pnpm perf:rust` (criterion

CONTRIBUTING.md

@@ -16,8 +16,7 @@ Project layout, coding rules, commands and checks are in [AGENTS.md](AGENTS.md).
 
 ## Pull requests
 
-- One issue per PR, linked with `Closes #123`. Feature PRs need a `planned` issue.
-  Docs, CI and pure refactors may skip the issue.
+- One problem per PR. If it resolves an issue, link it with `Closes #123`.
 - Reproduce the problem first, or write a test that fails before the fix.
 - Fix the cause, and check whether the same cause breaks anything nearby.
 - Keep the diff focused. Unrelated refactors go in their own PR.
@@ -31,5 +30,9 @@ Project layout, coding rules, commands and checks are in [AGENTS.md](AGENTS.md).
 - If a change needs a product decision you can't make, ask in the issue and stop
   rather than guessing.
 
-A check on each PR adds `needs-info` when the issue link or the verification
-section is missing, and removes it once they're filled in.
+Plugins: pull requests here add or change official plugins (`plugins/official/`)
+and the plugin API. Community plugins live in their authors' repositories and
+are listed through [l0ng-ai/openidea-plugins](https://github.com/l0ng-ai/openidea-plugins);
+see [`plugins/README.md`](plugins/README.md) § 8.1.
+
+A check on each PR adds `needs-info` when the verification section is missing, and removes it once it's filled in.

Cargo.lock

@@ -4038,7 +4038,7 @@ checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
 
 [[package]]
 name = "ide-agent"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "dunce",
  "encoding_rs",
@@ -4061,7 +4061,7 @@ dependencies = [
 
 [[package]]
 name = "ide-analysis"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "ast-grep-core",
  "ide-core",
@@ -4075,7 +4075,7 @@ dependencies = [
 
 [[package]]
 name = "ide-build"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "dirs 6.0.0",
  "dunce",
@@ -4090,7 +4090,7 @@ dependencies = [
 
 [[package]]
 name = "ide-clipboard"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "objc2 0.6.5",
  "objc2-app-kit 0.3.2",
@@ -4099,7 +4099,7 @@ dependencies = [
 
 [[package]]
 name = "ide-core"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "dunce",
  "encoding_rs",
@@ -4116,7 +4116,7 @@ dependencies = [
 
 [[package]]
 name = "ide-coverage"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "ide-core",
  "ide-run",
@@ -4130,7 +4130,7 @@ dependencies = [
 
 [[package]]
 name = "ide-dap"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "ide-core",
  "ide-jsonrpc",
@@ -4148,14 +4148,17 @@ dependencies = [
 
 [[package]]
 name = "ide-db"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "bb8",
  "dirs 6.0.0",
  "futures",
  "ide-core",
+ "ide-http",
  "ide-ssh",
  "parking_lot",
+ "reqwest",
+ "rustls",
  "serde",
  "serde_json",
  "specta",
@@ -4166,11 +4169,12 @@ dependencies = [
  "tokio-util",
  "toml 0.9.12+spec-1.1.0",
  "tracing",
+ "uuid",
 ]
 
 [[package]]
 name = "ide-docker"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "ide-core",
  "serde",
@@ -4181,9 +4185,29 @@ dependencies = [
  "which",
 ]
 
+[[package]]
+name = "ide-extension"
+version = "0.1.36"
+dependencies = [
+ "base64 0.22.1",
+ "blake3",
+ "ed25519-dalek",
+ "ide-core",
+ "parking_lot",
+ "semver",
+ "serde",
+ "serde_json",
+ "specta",
+ "specta-typescript",
+ "tempfile",
+ "toml 0.9.12+spec-1.1.0",
+ "tracing",
+ "zip",
+]
+
 [[package]]
 name = "ide-fonts"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "objc2-core-foundation",
  "objc2-core-text",
@@ -4195,7 +4219,7 @@ dependencies = [
 
 [[package]]
 name = "ide-github"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "ide-core",
  "ide-vcs",
@@ -4208,11 +4232,15 @@ dependencies = [
 
 [[package]]
 name = "ide-host"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
+ "base64 0.22.1",
+ "criterion",
  "dirs 6.0.0",
  "dunce",
  "encoding_rs",
+ "getrandom 0.3.4",
+ "globset",
  "ide-agent",
  "ide-analysis",
  "ide-build",
@@ -4220,12 +4248,15 @@ dependencies = [
  "ide-coverage",
  "ide-dap",
  "ide-db",
+ "ide-docker",
+ "ide-extension",
  "ide-http",
  "ide-index",
  "ide-jsonrpc",
  "ide-language",
  "ide-lsp",
  "ide-notebook",
+ "ide-plugin",
  "ide-remote",
  "ide-run",
  "ide-sdk",
@@ -4239,23 +4270,30 @@ dependencies = [
  "ide-vcs",
  "ide-vfs",
  "ide-workspace",
+ "ignore",
  "parking_lot",
+ "quick-xml",
+ "regex-syntax",
+ "reqwest",
  "rustix",
+ "semver",
  "serde",
  "serde_json",
  "specta",
  "specta-typescript",
  "tempfile",
  "tokio",
+ "toml 0.9.12+spec-1.1.0",
  "tracing",
  "tracing-subscriber",
  "uuid",
  "windows-sys 0.61.2",
+ "zip",
 ]
 
 [[package]]
 name = "ide-http"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "ide-core",
  "parking_lot",
@@ -4273,7 +4311,7 @@ dependencies = [
 
 [[package]]
 name = "ide-index"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "blake3",
  "criterion",
@@ -4295,7 +4333,7 @@ dependencies = [
 
 [[package]]
 name = "ide-jsonrpc"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "encoding_rs",
  "futures",
@@ -4303,6 +4341,7 @@ dependencies = [
  "parking_lot",
  "serde",
  "serde_json",
+ "tempfile",
  "thiserror 2.0.21",
  "tokio",
  "tokio-util",
@@ -4311,11 +4350,12 @@ dependencies = [
 
 [[package]]
 name = "ide-language"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "blake3",
  "criterion",
  "ide-core",
+ "ide-extension",
  "ide-text",
  "parking_lot",
  "regex-lite",
@@ -4366,7 +4406,7 @@ dependencies = [
 
 [[package]]
 name = "ide-lsp"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "dunce",
  "futures",
@@ -4392,7 +4432,7 @@ dependencies = [
 
 [[package]]
 name = "ide-notebook"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "futures",
  "ide-core",
@@ -4415,26 +4455,27 @@ dependencies = [
 
 [[package]]
 name = "ide-plugin"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
+ "blake3",
  "ide-core",
- "ide-language",
+ "ide-extension",
  "parking_lot",
+ "semver",
  "serde",
  "serde_json",
  "specta",
  "tempfile",
  "thiserror 2.0.21",
- "toml 0.9.12+spec-1.1.0",
+ "tokio",
  "tracing",
  "wasmtime",
  "wasmtime-wasi",
- "zip",
 ]
 
 [[package]]
 name = "ide-profiler"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "ide-core",
  "ide-run",
@@ -4447,7 +4488,7 @@ dependencies = [
 
 [[package]]
 name = "ide-remote"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "globset",
  "ide-core",
@@ -4464,7 +4505,7 @@ dependencies = [
 
 [[package]]
 name = "ide-run"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "dunce",
  "encoding_rs",
@@ -4487,7 +4528,7 @@ dependencies = [
 
 [[package]]
 name = "ide-sdk"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "dunce",
  "ide-core",
@@ -4506,7 +4547,7 @@ dependencies = [
 
 [[package]]
 name = "ide-search"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "criterion",
  "globset",
@@ -4526,7 +4567,7 @@ dependencies = [
 
 [[package]]
 name = "ide-spell"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "ide-core",
  "parking_lot",
@@ -4539,7 +4580,7 @@ dependencies = [
 
 [[package]]
 name = "ide-ssh"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "dirs 6.0.0",
  "flate2",
@@ -4558,7 +4599,7 @@ dependencies = [
 
 [[package]]
 name = "ide-syntax"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "ide-core",
  "ide-language",
@@ -4573,7 +4614,7 @@ dependencies = [
 
 [[package]]
 name = "ide-terminal"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "ide-core",
  "libc",
@@ -4586,7 +4627,7 @@ dependencies = [
 
 [[package]]
 name = "ide-text"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "criterion",
  "ide-core",
@@ -4598,7 +4639,7 @@ dependencies = [
 
 [[package]]
 name = "ide-tools"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "flate2",
  "hex",
@@ -4619,14 +4660,16 @@ dependencies = [
 
 [[package]]
 name = "ide-vcs"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
+ "blake3",
  "dunce",
  "encoding_rs",
  "gix",
  "ide-core",
  "ignore",
  "libc",
+ "redb",
  "regex-lite",
  "serde",
  "serde_json",
@@ -4638,7 +4681,7 @@ dependencies = [
 
 [[package]]
 name = "ide-vfs"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "chardetng",
  "dunce",
@@ -4660,7 +4703,7 @@ dependencies = [
 
 [[package]]
 name = "ide-web"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "ide-core",
  "open",
@@ -4676,7 +4719,7 @@ dependencies = [
 
 [[package]]
 name = "ide-workspace"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
  "blake3",
  "dunce",
@@ -4694,6 +4737,7 @@ dependencies = [
  "toml 0.9.12+spec-1.1.0",
  "toml_edit 0.25.17+spec-1.1.0",
  "tracing",
+ "uuid",
  "zip",
 ]
 
@@ -6148,8 +6192,9 @@ dependencies = [
 
 [[package]]
 name = "openidea"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
+ "base64 0.22.1",
  "blake3",
  "block2 0.6.2",
  "dirs 6.0.0",
@@ -6164,6 +6209,7 @@ dependencies = [
  "ide-dap",
  "ide-db",
  "ide-docker",
+ "ide-extension",
  "ide-fonts",
  "ide-github",
  "ide-host",
@@ -6195,6 +6241,8 @@ dependencies = [
  "objc2-foundation 0.3.2",
  "objc2-web-kit 0.3.2",
  "parking_lot",
+ "percent-encoding",
+ "security-framework",
  "serde",
  "serde_json",
  "specta",
@@ -7096,6 +7144,7 @@ dependencies = [
  "rustls-platform-verifier",
  "serde",
  "serde_json",
+ "serde_urlencoded",
  "sync_wrapper",
  "tokio",
  "tokio-rustls",
@@ -7454,6 +7503,12 @@ dependencies = [
  "wait-timeout",
 ]
 
+[[package]]
+name = "ryu"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
+
 [[package]]
 name = "saa"
 version = "5.6.2"
@@ -7758,6 +7813,18 @@ dependencies = [
  "serde_core",
 ]
 
+[[package]]
+name = "serde_urlencoded"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
+dependencies = [
+ "form_urlencoded",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
 [[package]]
 name = "serde_with"
 version = "3.24.0"

Cargo.toml

@@ -1,9 +1,11 @@
 [workspace]
 resolver = "3"
 members = ["crates/*", "src-tauri"]
+# Plugins and the guest SDK build for wasm32-wasip2 in their own workspaces.
+exclude = ["sdk", "plugins"]
 
 [workspace.package]
-version = "0.1.35"
+version = "0.1.36"
 edition = "2024"
 rust-version = "1.96"
 license = "Apache-2.0"
@@ -41,6 +43,8 @@ ide-ssh = { path = "crates/ide-ssh" }
 ide-remote = { path = "crates/ide-remote" }
 ide-host = { path = "crates/ide-host" }
 ide-notebook = { path = "crates/ide-notebook" }
+ide-extension = { path = "crates/ide-extension" }
+ide-plugin = { path = "crates/ide-plugin" }
 
 # serialization & IPC typing
 serde = { version = "1", features = ["derive"] }
@@ -69,6 +73,7 @@ ropey = "1.6"
 encoding_rs = "0.8"
 chardetng = "0.1"
 ignore = "0.4"
+base64 = "0.22"
 globset = "0.4"
 notify = "8"
 notify-debouncer-full = "0.6"
@@ -81,6 +86,7 @@ zip = { version = "9", default-features = false, features = ["deflate"] }
 # search, index, language
 grep-searcher = "0.1"
 grep-regex = "0.1"
+regex-syntax = "0.8"
 grep-matcher = "0.1"
 nucleo-matcher = "0.3"
 redb = "4"

README.md

@@ -14,6 +14,8 @@
    · 
   <a href="#benchmark">Benchmark</a>
   &nbsp;·&nbsp;
+  <a href="#plugins">Plugins</a>
+  &nbsp;·&nbsp;
   <a href="https://discord.gg/2Zy4yn7gP">Discord</a>
 </p>
 
@@ -45,6 +47,16 @@ IDEA analyses Python more deeply, so "ready" doesn't mean the same work on
 both sides. Both are measured from the outside, the same way: see
 [`perf/compare`](perf/compare) to run it on your machine and projects.
 
+## Plugins
+
+Plugins add actions, completion, quick fixes, tool windows, custom editors,
+themes, file icons and languages. They run as sandboxed WebAssembly components;
+themes, icon themes and languages need no code at all.
+
+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.
+
 ## License
 
 [Apache 2.0](LICENSE). Bundled third-party assets are listed in [`THIRD_PARTY_LICENSES.md`](THIRD_PARTY_LICENSES.md).

THIRD_PARTY_LICENSES.md

@@ -2,12 +2,12 @@
 
 ## Project Lombok
 
-`plugins/lombok/lombok-1.18.48-openidea.2.jar` contains Project Lombok v1.18.48 with the Equinox
+`java/lombok/lombok-1.18.48-openidea.2.jar` contains Project Lombok v1.18.48 with the Equinox
 classloader fix from [projectlombok/lombok#4059](https://github.com/projectlombok/lombok/pull/4059)
 and the ECJ constructor-call fix from [projectlombok/lombok#4089](https://github.com/projectlombok/lombok/pull/4089).
 Copyright (C) 2009-2021 The Project Lombok Authors. MIT license and bundled component
-notices are retained in [plugins/lombok/LICENSE](plugins/lombok/LICENSE) and inside the jar.
-Source tag, patch commits and build instructions: [plugins/lombok/README.md](plugins/lombok/README.md).
+notices are retained in [java/lombok/LICENSE](java/lombok/LICENSE) and inside the jar.
+Source tag, patch commits and build instructions: [java/lombok/README.md](java/lombok/README.md).
 
 ## JetBrains IntelliJ Platform icons
 
@@ -52,6 +52,15 @@ Their original copyright headers and Apache-2.0 licensing are retained.
 
 At render time `src/ui/icons.tsx` may recolour monochrome icons to `currentColor`.
 
+## JetBrains IntelliJ Platform VCS log graph algorithms
+
+`crates/ide-vcs/src/bek.rs` and `src/features/vcs/graph.ts` adapt the Bek ordering,
+graph layout and LinearBek merge linearization algorithms from
+[intellij-community](https://github.com/JetBrains/intellij-community/tree/1d70d5c54302d655758edbd2f808fb8dea8b1764/platform/vcs-log/graph/src/com/intellij/vcs/log/graph)
+(`impl/facade/sort/bek`, `impl/permanent/GraphLayoutBuilder.kt` and
+`linearBek/LinearBekGraphBuilder.java`). Modified from the originals.
+Copyright 2000-2026 JetBrains s.r.o. and contributors. Apache License 2.0 (below).
+
 ## JetBrains IntelliJ Platform diff algorithm
 
 `src/features/vcs/comparison/**` is a TypeScript port of the text comparison of

crates/ide-agent/src/config.rs

@@ -1,7 +1,9 @@
 //! Session settings (model, mode, thinking effort…), slash commands and context use, as
 //! the agent reports them over ACP.
 
-use crate::model::{AgentCommand, AgentConfigOption, AgentConfigValue, AgentConfigVia, AgentUsage};
+use crate::model::{
+    AgentCommand, AgentConfigOption, AgentConfigValue, AgentConfigVia, AgentCost, AgentLimit, AgentUsage,
+};
 use serde_json::{Value, json};
 
 /// Cursor exposes execution modes over ACP, but leaves approval policy to its client.
@@ -150,7 +152,27 @@ pub(crate) fn commands_of(update: &Value) -> Vec<AgentCommand> {
 /// `usage_update`: `{ used, size }`.
 pub(crate) fn usage_of(update: &Value) -> Option<AgentUsage> {
     let tokens = |key: &str| update.get(key)?.as_f64().map(|n| n.clamp(0.0, f64::from(u32::MAX)) as u32);
-    Some(AgentUsage { used: tokens("used")?, size: tokens("size").filter(|s| *s > 0)? })
+    let cost = update.get("cost").and_then(|c| {
+        Some(Box::new(AgentCost {
+            amount: c.get("amount")?.as_f64().filter(|a| a.is_finite() && *a >= 0.0)?,
+            currency: c.get("currency")?.as_str().filter(|c| !c.is_empty())?.to_owned(),
+        }))
+    });
+    Some(AgentUsage { used: tokens("used")?, size: tokens("size").filter(|s| *s > 0)?, cost })
+}
+
+/// The usage-limit windows a [`crate::LIMITS_UPDATE`] carries; malformed entries are skipped.
+pub(crate) fn limits_of(update: &Value) -> Vec<AgentLimit> {
+    let limits = update.get("limits").and_then(Value::as_array).into_iter().flatten();
+    limits
+        .filter_map(|l| {
+            Some(AgentLimit {
+                window: l.get("window")?.as_str().filter(|w| !w.is_empty())?.to_owned(),
+                used_percent: l.get("usedPercent")?.as_f64().filter(|p| p.is_finite())?.clamp(0.0, 100.0),
+                resets_ms: l.get("resetsMs").and_then(Value::as_f64),
+            })
+        })
+        .collect()
 }
 
 fn legacy(

crates/ide-agent/src/lib.rs

@@ -29,7 +29,7 @@ use serde::{Deserialize, Serialize};
 use serde_json::{Value, json};
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet, VecDeque};
 use std::path::{Path, PathBuf};
-use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering};
 use std::sync::{Arc, Weak};
 use std::time::Duration;
 
@@ -44,15 +44,22 @@ const REPLAY_GRACE: Duration = Duration::from_millis(300);
 /// can trail its `session/prompt` response by this much.
 const TURN_GRACE: Duration = Duration::from_millis(100);
 const STDERR_LINES: usize = 20;
+/// An agent idle this long after its turn is stopped when it can reload its session
+/// (`session/load`): the next message starts it again where it left off.
+const IDLE_RELEASE: Duration = Duration::from_secs(5 * 60);
 /// Updates of a session's state rather than its conversation.
 const SESSION_STATE: [&str; 5] =
     ["session_info_update", "config_option_update", "current_mode_update", "available_commands_update", "usage_update"];
 /// A native agent's own update: it is about to retry a failed API request (see [`AgentRetry`]).
 pub(crate) const RETRY_UPDATE: &str = "openidea_retry";
+/// A native agent's own update: the usage limits of its account (see [`AgentLimit`]).
+pub(crate) const LIMITS_UPDATE: &str = "openidea_limits";
 /// Referenced files up to this size are embedded in the prompt (when the agent takes it).
 const MAX_EMBED: u64 = 256 * 1024;
 /// How long a probe waits for the agent to answer `initialize`.
 const PROBE_TIMEOUT: Duration = Duration::from_secs(30);
+/// How long deleting a task waits for its agent to exit before removing the worktree.
+const EXIT_WAIT: Duration = Duration::from_secs(5);
 
 /// The agent tasks of one project.
 pub struct AgentManager {
@@ -90,6 +97,8 @@ struct Shared {
     providers: RwLock<Vec<provider::ProviderSpec>>,
     /// Last probe of each provider.
     probes: Mutex<HashMap<String, AgentProbe>>,
+    /// [`IDLE_RELEASE`], in milliseconds (shorter in tests).
+    idle_release_ms: AtomicU64,
 }
 
 /// What an agent offered in its last session, for the New Task page.
@@ -205,6 +214,8 @@ struct Live {
     capabilities: AgentCapabilities,
     /// `promptCapabilities.embeddedContext`: referenced files are sent with their text.
     embedded: bool,
+    /// `session/load`: the process can be stopped between turns and the session reloaded.
+    resumable: bool,
 }
 
 struct Task {
@@ -226,6 +237,8 @@ struct Task {
     cancel_pending: AtomicBool,
     /// The agent reported something for the current turn.
     turn_started: AtomicBool,
+    /// Turns sent so far: an idle release scheduled before the latest one is void.
+    turns: AtomicU64,
     /// Settings already sent this session (`(option, value)`), so a refusal is not retried.
     config_sent: Mutex<HashSet<(String, String)>>,
     dirty: Mutex<BTreeSet<(Session, usize)>>,
@@ -236,6 +249,11 @@ struct Task {
 }
 
 impl AgentManager {
+    #[cfg(test)]
+    fn set_idle_release(&self, delay: Duration) {
+        self.shared.idle_release_ms.store(delay.as_millis() as u64, Ordering::Relaxed);
+    }
+
     /// Loads the project's saved tasks. Spawned work runs on `runtime`.
     pub fn new(paths: AgentPaths, runtime: tokio::runtime::Handle) -> Self {
         let connector: Connector = Arc::new(|spec, cwd, client, on_stderr| match spec.driver {
@@ -260,6 +278,7 @@ impl AgentManager {
             known: Mutex::new(known),
             providers,
             probes: Mutex::new(HashMap::new()),
+            idle_release_ms: AtomicU64::new(IDLE_RELEASE.as_millis() as u64),
         });
         let mut tasks = HashMap::new();
         for file in std::fs::read_dir(&shared.paths.store_dir).into_iter().flatten().flatten() {
@@ -328,6 +347,14 @@ impl AgentManager {
         provider::set_builtin_command(&dir, id, command.as_deref())
     }
 
+    /// Sets the environment variables built-in `id` starts with; empty clears them.
+    pub fn set_builtin_env(&self, id: &str, env: std::collections::BTreeMap<String, String>) -> IdeResult<()> {
+        let Some(dir) = self.shared.paths.custom_agents_dir.clone() else {
+            return Err(IdeError::unavailable("there is no custom agents directory"));
+        };
+        provider::set_builtin_env(&dir, id, env)
+    }
+
     /// Re-reads configured/installed agents, drops cached probes, and notifies subscribers.
     pub fn reload_providers(&self) {
         let specs = provider::load(self.shared.paths.custom_agents_dir.as_deref());
@@ -814,7 +841,7 @@ impl AgentManager {
     /// Forgets the task; with `remove_worktree` also deletes its worktree (the branch stays).
     pub async fn delete(&self, id: &str, remove_worktree: bool) -> IdeResult<()> {
         let task = self.task(id)?;
-        task.kill();
+        let live = task.kill();
         let (isolation, cwd, root) = {
             let s = task.state.lock();
             (
@@ -826,6 +853,11 @@ impl AgentManager {
         // A copy of the task (a fork) may work in the same worktree.
         let shared = self.tasks.read().values().any(|t| t.id != id && t.state.lock().task.cwd.0 == cwd);
         if remove_worktree && !shared && isolation == Isolation::Worktree && cwd.exists() {
+            // On Windows the agent's processes lock the folder (their working directory,
+            // open files) until they have exited.
+            if let Some(peer) = live {
+                let _ = tokio::time::timeout(EXIT_WAIT, peer.exited()).await;
+            }
             let worktrees = self.shared.paths.worktrees_dir.clone();
             blocking(move || worktree::remove(&root, &worktrees, &cwd)).await?;
         }
@@ -886,6 +918,7 @@ impl Task {
             send_now: AtomicBool::new(false),
             cancel_pending: AtomicBool::new(false),
             turn_started: AtomicBool::new(false),
+            turns: AtomicU64::new(0),
             config_sent: Mutex::new(HashSet::new()),
             dirty: Mutex::new(BTreeSet::new()),
             flush_scheduled: AtomicBool::new(false),
@@ -1028,12 +1061,42 @@ impl Task {
             }
             match (next, result) {
                 (Some(queued), _) => prompt = queued.prompt,
-                (None, Ok(_)) => return self.set_status(AgentStatus::Ready, None),
+                (None, Ok(_)) => {
+                    self.set_status(AgentStatus::Ready, None);
+                    return self.release_when_idle();
+                }
                 (None, Err(failure)) => return self.fail(failure),
             }
         }
     }
 
+    /// Stops the agent's process once the task has stayed idle for [`IDLE_RELEASE`], so
+    /// finished tasks don't keep an agent (and what it started) running. Only an agent that
+    /// reloads its session: the next message starts it again with the conversation intact.
+    fn release_when_idle(self: &Arc<Self>) {
+        let turn = self.turns.load(Ordering::Acquire);
+        let delay = Duration::from_millis(self.shared.idle_release_ms.load(Ordering::Relaxed));
+        let task = Arc::downgrade(self);
+        self.shared.runtime.spawn(async move {
+            tokio::time::sleep(delay).await;
+            let Some(task) = task.upgrade() else { return };
+            if task.turns.load(Ordering::Acquire) != turn
+                || task.state.lock().busy
+                || !task.permissions.lock().is_empty()
+            {
+                return;
+            }
+            let live = {
+                let mut live = task.live.lock();
+                if live.as_ref().is_some_and(|l| l.resumable && !l.peer.is_closed()) { live.take() } else { None }
+            };
+            if let Some(live) = live {
+                tracing::debug!("agent task {}: idle, stopping the agent until the next message", task.id);
+                live.peer.kill();
+            }
+        });
+    }
+
     /// Ends a turn that failed: nothing it started stays open.
     fn fail(self: &Arc<Self>, failure: Failure) {
         self.cancel_permissions();
@@ -1094,6 +1157,7 @@ impl Task {
 
     /// Sends one prompt, starting the agent first if needed; returns the stop reason.
     async fn turn(self: &Arc<Self>, prompt: &AgentPrompt) -> Result<String, Failure> {
+        self.turns.fetch_add(1, Ordering::AcqRel);
         self.turn_started.store(false, Ordering::Release);
         self.state.lock().task.resets_ms = None;
         let attachments = prompt
@@ -1290,7 +1354,7 @@ impl Task {
         }
         self.persist();
         self.emit_task();
-        let live = Live { peer, session: session_id, capabilities, embedded };
+        let live = Live { peer, session: session_id, capabilities, embedded, resumable: can_load };
         *self.live.lock() = Some(live.clone());
         Ok(live)
     }
@@ -1372,6 +1436,13 @@ impl Task {
             }
             return;
         }
+        if kind == LIMITS_UPDATE {
+            if !self.replaying.load(Ordering::Acquire) {
+                let provider = self.state.lock().task.provider.clone();
+                self.shared.emit(AgentEvent::Limits { provider, limits: config::limits_of(update) });
+            }
+            return;
+        }
         if kind == "session_info_update" {
             // The agent's own title for the session replaces the first line of the prompt.
             let title = update.get("title").and_then(Value::as_str).map(str::trim).filter(|t| !t.is_empty());
@@ -1541,11 +1612,12 @@ impl Task {
         }
     }
 
-    fn kill(&self) {
+    /// Stops the agent; returns its connection, to wait for its process to exit.
+    fn kill(&self) -> Option<acp::Conn> {
         self.cancel_permissions();
-        if let Some(live) = self.live.lock().take() {
-            live.peer.kill();
-        }
+        let live = self.live.lock().take()?;
+        live.peer.kill();
+        Some(live.peer)
     }
 }
 

crates/ide-agent/src/model.rs

@@ -3,6 +3,7 @@
 use ide_core::IpcPath;
 use serde::{Deserialize, Serialize};
 use specta::Type;
+use std::collections::BTreeMap;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
 #[serde(rename_all = "camelCase")]
@@ -154,6 +155,30 @@ pub struct AgentUsage {
     pub used: u32,
     /// Size of the context window.
     pub size: u32,
+    /// What the session has cost so far (ACP `usage_update.cost`), when the agent reports it.
+    // Boxed so that `AgentEvent::Task` stays within clippy's `large_enum_variant` bound on Windows.
+    #[serde(default)]
+    pub cost: Option<Box<AgentCost>>,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct AgentCost {
+    pub amount: f64,
+    /// ISO 4217 code, e.g. `USD`.
+    pub currency: String,
+}
+
+/// One usage-limit window of an agent's account.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct AgentLimit {
+    /// The window as the agent names it: `five_hour`, `seven_day`, `seven_day_opus`…
+    pub window: String,
+    /// Share of the window used, 0–100.
+    pub used_percent: f64,
+    /// When the window resets (ms since the epoch), if the agent said.
+    pub resets_ms: Option<f64>,
 }
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
@@ -333,6 +358,8 @@ pub struct AgentProvider {
     pub command_read_only_reason: Option<AgentCommandReadOnlyReason>,
     /// Whether the command was found (on `PATH`).
     pub installed: bool,
+    /// Environment variables it starts with (from its agent file).
+    pub env: BTreeMap<String, String>,
     /// Settings (models, modes…) the agent offered last time it ran; empty before its first session.
     pub config: Vec<AgentConfigOption>,
     /// Slash commands it offered last time.
@@ -431,6 +458,11 @@ pub enum AgentEvent {
         index: u32,
         entry: AgentEntry,
     },
+    /// An agent reported the usage limits of its account (shared by every task of `provider`).
+    Limits {
+        provider: String,
+        limits: Vec<AgentLimit>,
+    },
     /// The installed or configured agent providers changed.
     Providers,
 }

crates/ide-agent/src/native/claude/cli.rs

@@ -98,6 +98,8 @@ impl Cli for Process {
         use std::process::Stdio;
         let mut cmd = tokio::process::Command::new(&l.program);
         ide_core::process::prepare(cmd.as_std_mut());
+        // `claude` may be a wrapper (`claude.cmd` → node): stopping it stops what it started.
+        ide_core::process::own_group(cmd.as_std_mut());
         cmd.args(&l.args)
             .current_dir(&l.cwd)
             .envs(ide_core::process::shell_env())
@@ -120,6 +122,9 @@ impl Cli for Process {
             tokio::select! {
                 _ = child.wait() => {}
                 _ = token.cancelled() => {
+                    if let Some(pid) = child.id() {
+                        let _ = tokio::task::spawn_blocking(move || ide_core::process::kill_tree_of(pid)).await;
+                    }
                     let _ = child.start_kill();
                     let _ = child.wait().await;
                 }

crates/ide-agent/src/native/claude/mod.rs

@@ -904,6 +904,7 @@ impl Session {
                     if info.get("status").and_then(Value::as_str) == Some("rejected") {
                         st.limit_resets_ms = info.get("resetsAt").and_then(Value::as_f64).map(|s| s * 1000.0);
                     }
+                    updates.extend(st.tr.on_rate_limit(&info));
                 }
                 "command_lifecycle" => {
                     let uuid = msg.get("command_uuid").and_then(Value::as_str);

crates/ide-agent/src/native/claude/tests.rs

@@ -1013,6 +1013,39 @@ fn streamed_text_is_not_sent_twice() {
     assert_eq!(usage[0].update, json!({"sessionUpdate": "usage_update", "used": 15, "size": 1000}));
 }
 
+#[test]
+fn rate_limits_and_cost() {
+    let mut t = Translator::new("s", PathBuf::from("/w"), false);
+    let info = json!({"status": "allowed", "rateLimitType": "five_hour", "unifiedWindows": {
+        "five_hour": {"utilization": 0.19, "resetsAt": 100, "status": "allowed"},
+        "seven_day": {"utilization": 0.09, "resetsAt": 200, "status": "allowed"},
+    }});
+    let limits = t.on_rate_limit(&info).unwrap();
+    assert_eq!(limits.session, "s");
+    assert_eq!(limits.update["sessionUpdate"], crate::LIMITS_UPDATE);
+    let windows: Vec<(&str, i64, f64)> = limits.update["limits"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .map(|l| {
+            (
+                l["window"].as_str().unwrap(),
+                l["usedPercent"].as_f64().unwrap().round() as i64,
+                l["resetsMs"].as_f64().unwrap(),
+            )
+        })
+        .collect();
+    assert_eq!(windows, [("five_hour", 19, 100_000.0), ("seven_day", 9, 200_000.0)]);
+    // Older versions report the window that applies, alone.
+    let single = t.on_rate_limit(&json!({"rateLimitType": "seven_day", "utilization": 0.5})).unwrap();
+    assert_eq!(single.update["limits"], json!([{"window": "seven_day", "usedPercent": 50.0, "resetsMs": null}]));
+    assert_eq!(t.on_rate_limit(&json!({"status": "allowed", "resetsAt": 100})), None, "no utilization, no update");
+
+    t.used = Some(10);
+    let usage = t.on_result(&json!({"total_cost_usd": 0.5, "modelUsage": {"x": {"contextWindow": 1000}}}));
+    assert_eq!(usage[0].update["cost"], json!({"amount": 0.5, "currency": "USD"}));
+}
+
 #[test]
 fn tool_calls_plans_and_subagents() {
     let mut t = Translator::new("s", PathBuf::from("/w"), true);

crates/ide-agent/src/native/claude/translate.rs

@@ -5,7 +5,7 @@
 //! Agent tool use that launched them: their messages carry it as `parent_tool_use_id`.
 
 use super::tools;
-use crate::RETRY_UPDATE;
+use crate::{LIMITS_UPDATE, RETRY_UPDATE};
 use serde_json::{Value, json};
 use std::collections::{HashMap, VecDeque};
 use std::path::PathBuf;
@@ -58,6 +58,8 @@ pub(super) struct Translator {
     pub used: Option<u64>,
     pub model: Option<String>,
     windows: HashMap<String, u64>,
+    /// The session's cost so far in USD, as the last `result` reported it.
+    cost_usd: Option<f64>,
 }
 
 impl Translator {
@@ -75,6 +77,7 @@ impl Translator {
             used: None,
             model: None,
             windows: HashMap::new(),
+            cost_usd: None,
         }
     }
 
@@ -543,6 +546,9 @@ impl Translator {
                 self.windows.insert(model.clone(), w);
             }
         }
+        if let Some(cost) = result.get("total_cost_usd").and_then(Value::as_f64).filter(|c| c.is_finite()) {
+            self.cost_usd = Some(cost);
+        }
         self.usage_update().into_iter().collect()
     }
 
@@ -557,9 +563,33 @@ impl Translator {
                     .or_else(|| self.windows.iter().find(|(k, _)| k.starts_with(m.as_str())).map(|(_, v)| v))
             })
             .or_else(|| (self.windows.len() == 1).then(|| self.windows.values().next()).flatten())?;
-        Some(Update {
+        let mut update = json!({ "sessionUpdate": "usage_update", "used": used, "size": size });
+        if let Some(amount) = self.cost_usd {
+            update["cost"] = json!({ "amount": amount, "currency": "USD" });
+        }
+        Some(Update { session: self.root.clone(), update })
+    }
+
+    /// The usage-limit windows a `rate_limit_event` reports, as a [`LIMITS_UPDATE`]: every
+    /// window of `unifiedWindows`, or the single `rateLimitType` window older versions send.
+    pub fn on_rate_limit(&self, info: &Value) -> Option<Update> {
+        let window = |name: &str, w: &Value| {
+            let utilization = w.get("utilization")?.as_f64()?;
+            Some(json!({
+                "window": name,
+                "usedPercent": utilization * 100.0,
+                "resetsMs": w.get("resetsAt").and_then(Value::as_f64).map(|s| s * 1000.0),
+            }))
+        };
+        let limits: Vec<Value> = match info.get("unifiedWindows").and_then(Value::as_object) {
+            Some(windows) => windows.iter().filter_map(|(name, w)| window(name, w)).collect(),
+            None => {
+                info.get("rateLimitType").and_then(Value::as_str).and_then(|t| window(t, info)).into_iter().collect()
+            }
+        };
+        (!limits.is_empty()).then(|| Update {
             session: self.root.clone(),
-            update: json!({ "sessionUpdate": "usage_update", "used": used, "size": size }),
+            update: json!({ "sessionUpdate": LIMITS_UPDATE, "limits": limits }),
         })
     }
 }

crates/ide-agent/src/provider.rs

@@ -124,6 +124,7 @@ pub(crate) fn describe(spec: &ProviderSpec) -> AgentProvider {
         command_editable: reason.is_none(),
         command_read_only_reason: reason,
         installed: installed(&spec.command),
+        env: spec.env.iter().cloned().collect(),
         config: vec![],
         commands: vec![],
         source: spec.source.clone(),
@@ -133,6 +134,16 @@ pub(crate) fn describe(spec: &ProviderSpec) -> AgentProvider {
 /// Overrides built-in `id`'s command through its agent file, preserving other
 /// customizations. `None` restores the built-in command and removes a redundant file.
 pub(crate) fn set_builtin_command(custom_dir: &Path, id: &str, command: Option<&str>) -> IdeResult<()> {
+    update_builtin(custom_dir, id, |agent, builtin| agent.command = command.unwrap_or(&builtin.command).to_owned())
+}
+
+/// The environment built-in `id` starts with, through its agent file (empty clears it).
+pub(crate) fn set_builtin_env(custom_dir: &Path, id: &str, env: BTreeMap<String, String>) -> IdeResult<()> {
+    update_builtin(custom_dir, id, |agent, _| agent.env = env)
+}
+
+/// Changes built-in `id`'s agent file; a file left with only the built-in's values is removed.
+fn update_builtin(custom_dir: &Path, id: &str, change: impl FnOnce(&mut CustomAgent, &ProviderSpec)) -> IdeResult<()> {
     let Some(builtin) = builtin_spec(id) else {
         return Err(IdeError::invalid(format!("{id} is not a built-in agent")));
     };
@@ -152,7 +163,8 @@ pub(crate) fn set_builtin_command(custom_dir: &Path, id: &str, command: Option<&
     if agent.registry.is_some() {
         return Err(IdeError::invalid(format!("{id} is installed from the ACP Registry")));
     }
-    if command.is_none()
+    change(&mut agent, &builtin);
+    if agent.command == builtin.command
         && agent.name.as_deref() == Some(builtin.name.as_str())
         && agent.driver == builtin.driver
         && agent.args == builtin.args
@@ -164,7 +176,6 @@ pub(crate) fn set_builtin_command(custom_dir: &Path, id: &str, command: Option<&
         }
         return Ok(());
     }
-    agent.command = command.unwrap_or(&builtin.command).to_owned();
     agent.write(&file)?;
     Ok(())
 }
@@ -368,6 +379,23 @@ mod tests {
         assert!(installed("sh"));
     }
 
+    #[test]
+    fn set_builtin_env_writes_and_clears_the_environment() {
+        let dir = tempfile::tempdir().unwrap();
+        let env = BTreeMap::from([("CLAUDE_CODE_ENTRYPOINT".to_owned(), "openidea".to_owned())]);
+        set_builtin_env(dir.path(), "claude", env.clone()).unwrap();
+        let claude = load(Some(dir.path())).into_iter().find(|s| s.id == "claude").unwrap();
+        assert_eq!(claude.env, vec![("CLAUDE_CODE_ENTRYPOINT".to_owned(), "openidea".to_owned())]);
+        assert_eq!(describe(&claude).env, env);
+        // The command override and the environment are kept independently.
+        set_builtin_command(dir.path(), "claude", Some("/opt/claude")).unwrap();
+        set_builtin_command(dir.path(), "claude", None).unwrap();
+        assert!(dir.path().join("claude.toml").is_file());
+        set_builtin_env(dir.path(), "claude", BTreeMap::new()).unwrap();
+        assert!(!dir.path().join("claude.toml").exists());
+        set_builtin_env(dir.path(), "not-a-builtin", env).unwrap_err();
+    }
+
     #[test]
     fn set_builtin_command_overrides_and_clears_a_builtin() {
         let dir = tempfile::tempdir().unwrap();

crates/ide-agent/src/tests.rs

@@ -9,6 +9,8 @@ struct FakeAgent {
     /// Every connection's agent side, kept open.
     servers: Mutex<Vec<Peer>>,
     calls: Mutex<Vec<String>>,
+    /// Without `loadSession` (a session lives only as long as its process).
+    no_load: bool,
 }
 
 impl FakeAgent {
@@ -89,7 +91,7 @@ impl Handler for FakeAgent {
                 if params.pointer("/clientCapabilities/subagents").is_some_and(Value::is_object) {
                     self.calls.lock().push("subagents".into());
                 }
-                Ok(json!({"protocolVersion": 1, "agentCapabilities": {"loadSession": true,
+                Ok(json!({"protocolVersion": 1, "agentCapabilities": {"loadSession": !self.no_load,
                     "sessionCapabilities": {"fork": {}}, "_meta": {"openidea": {"rollback": true, "steer": true}}}}))
             }
             "session/new" => Ok(json!({"sessionId": "s1",
@@ -145,7 +147,16 @@ impl Handler for FakeAgent {
                     json!({"sessionUpdate": "available_commands_update",
                     "availableCommands": [{"name": "review", "description": "Review", "input": {"hint": "focus"}}]}),
                 );
-                self.update(&session, json!({"sessionUpdate": "usage_update", "used": 50, "size": 1000}));
+                self.update(
+                    &session,
+                    json!({"sessionUpdate": "usage_update", "used": 50, "size": 1000,
+                    "cost": {"amount": 0.25, "currency": "USD"}}),
+                );
+                self.update(
+                    &session,
+                    json!({"sessionUpdate": LIMITS_UPDATE,
+                    "limits": [{"window": "five_hour", "usedPercent": 19.0, "resetsMs": 5000.0}]}),
+                );
                 self.update(&session, json!({"sessionUpdate": "session_info_update", "title": "Lexer fix"}));
                 self.say(&session, "Hi");
                 self.update(
@@ -358,6 +369,10 @@ async fn a_task_runs_asks_for_permission_and_survives_a_restart() {
         assert_eq!((modes.via, modes.current.as_deref()), (AgentConfigVia::Mode, Some("ask")));
         assert_eq!(t.commands.iter().map(|c| c.name.as_str()).collect::<Vec<_>>(), ["review"]);
         assert_eq!(t.usage.as_ref().map(|u| (u.used, u.size)), Some((50, 1000)));
+        assert_eq!(
+            t.usage.as_ref().and_then(|u| u.cost.clone()),
+            Some(Box::new(AgentCost { amount: 0.25, currency: "USD".into() }))
+        );
         assert_eq!(t.title, "Lexer fix", "the agent's title replaces the prompt's first line");
     }
     mgr.set_config(&task.id, "mode", "code".into()).await.unwrap();
@@ -370,6 +385,18 @@ async fn a_task_runs_asks_for_permission_and_survives_a_restart() {
         assert!(
             events.iter().any(|e| matches!(e, AgentEvent::Task { task } if task.status == AgentStatus::NeedsInput))
         );
+        let limits = events.iter().find_map(|e| match e {
+            AgentEvent::Limits { provider, limits } => Some((provider.as_str(), limits.clone())),
+            _ => None,
+        });
+        assert_eq!(
+            limits,
+            Some((
+                task.provider.as_str(),
+                vec![AgentLimit { window: "five_hour".into(), used_percent: 19.0, resets_ms: Some(5000.0) }]
+            )),
+            "an agent's usage limits are its provider's"
+        );
         let last_entry = events.iter().rev().find_map(|e| match e {
             AgentEvent::Entry { index, entry, .. } if !matches!(entry, AgentEntry::User { .. }) => {
                 Some((*index, entry.clone()))
@@ -772,6 +799,18 @@ fn retry_updates_become_a_countdown() {
     assert_eq!(retry_of(&json!({"sessionUpdate": RETRY_UPDATE}), 0.0), None, "no attempt");
 }
 
+#[test]
+fn usage_limits_and_cost_skip_what_is_malformed() {
+    let limits = config::limits_of(&json!({"sessionUpdate": LIMITS_UPDATE, "limits": [
+        {"window": "seven_day", "usedPercent": 140.0},
+        {"window": "", "usedPercent": 10.0},
+        {"window": "five_hour"},
+    ]}));
+    assert_eq!(limits, [AgentLimit { window: "seven_day".into(), used_percent: 100.0, resets_ms: None }]);
+    let usage = config::usage_of(&json!({"used": 1, "size": 2, "cost": {"amount": -1.0, "currency": "USD"}}));
+    assert_eq!(usage.map(|u| u.cost), Some(None), "a negative cost is dropped, the context use kept");
+}
+
 #[tokio::test(flavor = "multi_thread")]
 async fn cursor_approval_switch_resolves_pending_and_survives_restart() {
     let tmp = tempfile::tempdir().unwrap();
@@ -1017,3 +1056,167 @@ async fn reload_providers_updates_registry_install_clears_stale_probes_and_notif
     let probe = mgr.probe("copilot", false).await.unwrap();
     assert!(probe.error.is_none());
 }
+
+#[tokio::test(flavor = "multi_thread")]
+async fn idle_agents_stop_and_resume_their_session_on_the_next_message() {
+    let new = || NewAgentTask {
+        project_root: None,
+        prompt: text("again"),
+        provider: "claude".into(),
+        config: Vec::new(),
+        isolation: Isolation::Local,
+        base: None,
+    };
+    let live =
+        |mgr: &AgentManager, id: &str| mgr.task(id).unwrap().live.lock().as_ref().is_some_and(|l| !l.peer.is_closed());
+
+    let tmp = tempfile::tempdir().unwrap();
+    let agent = Arc::new(FakeAgent::default());
+    let mgr = manager(tmp.path(), agent.clone());
+    mgr.set_idle_release(Duration::from_millis(200));
+    let task = mgr.create(new()).await.unwrap();
+    wait_for(&mgr, &task.id, AgentStatus::Ready).await;
+    assert!(live(&mgr, &task.id));
+    // The process is stopped once the task stays idle…
+    tokio::time::sleep(Duration::from_millis(600)).await;
+    assert!(!live(&mgr, &task.id));
+    assert!(agent.servers.lock()[0].is_closed(), "its connection is closed");
+    assert_eq!(mgr.task(&task.id).unwrap().state.lock().task.status, AgentStatus::Ready, "not an error");
+    // …and the next message starts it again on the same session.
+    mgr.prompt(&task.id, text("again"), false).await.unwrap();
+    wait_for(&mgr, &task.id, AgentStatus::Ready).await;
+    assert!(agent.calls.lock().contains(&"session/load".to_owned()));
+    assert_eq!(
+        mgr.entries(&task.id, None).unwrap().iter().filter(|e| matches!(e, AgentEntry::Agent { .. })).count(),
+        2
+    );
+
+    // A new turn before the delay ran out keeps the agent.
+    mgr.prompt(&task.id, text("again"), false).await.unwrap();
+    tokio::time::sleep(Duration::from_millis(100)).await;
+    wait_for(&mgr, &task.id, AgentStatus::Ready).await;
+    assert!(live(&mgr, &task.id));
+    mgr.shutdown();
+
+    // An agent that can't reload its session keeps running: stopping it would lose the conversation.
+    let tmp = tempfile::tempdir().unwrap();
+    let agent = Arc::new(FakeAgent { no_load: true, ..FakeAgent::default() });
+    let mgr = manager(tmp.path(), agent.clone());
+    mgr.set_idle_release(Duration::from_millis(200));
+    let task = mgr.create(new()).await.unwrap();
+    wait_for(&mgr, &task.id, AgentStatus::Ready).await;
+    tokio::time::sleep(Duration::from_millis(600)).await;
+    assert!(live(&mgr, &task.id));
+    mgr.shutdown();
+}
+
+/// Deleting a task whose agent still runs in the worktree removes both and leaves no
+/// process behind, whether it is waiting for permission or idle without session/load.
+#[tokio::test(flavor = "multi_thread")]
+async fn deleting_a_task_waits_for_its_agent_to_exit_before_removing_the_worktree() {
+    for no_load in [false, true] {
+        delete_running_agent(no_load).await;
+    }
+}
+
+async fn delete_running_agent(no_load: bool) {
+    let tmp = tempfile::tempdir().unwrap();
+    let root = dunce::canonicalize(tmp.path()).unwrap();
+    let git = |args: &[&str]| {
+        let out = std::process::Command::new("git")
+            .args(["-c", "user.name=t", "-c", "user.email=t@t", "-c", "commit.gpgsign=false"])
+            .args(args)
+            .current_dir(&root)
+            .output()
+            .unwrap();
+        assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
+    };
+    git(&["init", "-q", "-b", "main"]);
+    std::fs::write(root.join("file.txt"), "original\n").unwrap();
+    git(&["add", "."]);
+    git(&["commit", "-qm", "initial"]);
+
+    let agent = Arc::new(FakeAgent { no_load, ..FakeAgent::default() });
+    let pids: Arc<Mutex<Vec<u32>>> = Arc::default();
+    let (fake, started) = (agent.clone(), pids.clone());
+    // The fake agent, served on behalf of a real process that exits only when killed.
+    let connector: Connector = Arc::new(move |_spec, cwd, client, _stderr| {
+        #[cfg(unix)]
+        let mut cmd = {
+            let mut cmd = tokio::process::Command::new("sleep");
+            cmd.arg("30");
+            cmd
+        };
+        #[cfg(windows)]
+        let mut cmd = {
+            let mut cmd = tokio::process::Command::new("cmd");
+            cmd.args(["/D", "/C", "echo ready>agent-ready & ping -n 30 127.0.0.1 >nul"]);
+            cmd
+        };
+        ide_core::process::prepare(cmd.as_std_mut());
+        ide_core::process::own_group(cmd.as_std_mut());
+        cmd.current_dir(cwd).kill_on_drop(true);
+        let child = cmd.spawn()?;
+        started.lock().push(child.id().unwrap());
+        let (a, b) = duplex(1 << 20);
+        let (ar, aw) = tokio::io::split(a);
+        let (br, bw) = tokio::io::split(b);
+        // `connect_with_child` frames with Content-Length.
+        fake.servers.lock().push(Peer::connect(br, bw, fake.clone()));
+        Ok(Peer::connect_with_child(ar, aw, client, child))
+    });
+    let mgr = AgentManager::with_connector(
+        AgentPaths {
+            project_root: root.clone(),
+            store_dir: root.join("store"),
+            worktrees_dir: root.join("worktrees"),
+            models_file: root.join("models.json"),
+            custom_agents_dir: None,
+            home_dir: None,
+        },
+        tokio::runtime::Handle::current(),
+        connector,
+    );
+    let task = mgr
+        .create(NewAgentTask {
+            project_root: None,
+            prompt: text(if no_load { "again" } else { "Fix the lexer" }),
+            provider: "claude".into(),
+            config: vec![],
+            isolation: Isolation::Worktree,
+            base: None,
+        })
+        .await
+        .unwrap();
+    wait_for(&mgr, &task.id, if no_load { AgentStatus::Ready } else { AgentStatus::NeedsInput }).await;
+    let pid = *pids.lock().last().expect("the agent was started");
+
+    #[cfg(windows)]
+    {
+        tokio::time::timeout(Duration::from_secs(5), async {
+            while !task.cwd.0.join("agent-ready").exists() {
+                tokio::time::sleep(Duration::from_millis(10)).await;
+            }
+        })
+        .await
+        .unwrap();
+        assert_eq!(
+            std::fs::rename(&task.cwd.0, task.cwd.0.with_extension("moved")).unwrap_err().raw_os_error(),
+            Some(32),
+            "the running agent really locks its worktree"
+        );
+    }
+
+    mgr.delete(&task.id, true).await.unwrap();
+    assert!(!task.cwd.0.exists());
+    // Killed and reaped: not even a zombie is left.
+    #[cfg(unix)]
+    let alive = std::process::Command::new("kill").args(["-0", &pid.to_string()]).status().unwrap().success();
+    #[cfg(windows)]
+    let alive = {
+        let mut cmd = std::process::Command::new("tasklist");
+        ide_core::process::prepare(&mut cmd).args(["/FI", &format!("PID eq {pid}"), "/FO", "CSV", "/NH"]);
+        String::from_utf8_lossy(&cmd.output().unwrap().stdout).contains(&format!("\"{pid}\""))
+    };
+    assert!(!alive, "the agent (pid {pid}) is still running");
+}

crates/ide-agent/src/worktree.rs

@@ -5,7 +5,7 @@ use ide_core::{IdeError, IdeResult, IpcPath};
 use ide_vcs::{ChangeKind, Repo};
 use std::collections::BTreeMap;
 use std::path::{Path, PathBuf};
-use std::time::UNIX_EPOCH;
+use std::time::{Duration, UNIX_EPOCH};
 
 pub(crate) struct Created {
     pub path: PathBuf,
@@ -65,7 +65,27 @@ pub(crate) fn remove(project_root: &Path, worktrees_dir: &Path, path: &Path) ->
     if !path.starts_with(worktrees_dir) || path == worktrees_dir {
         return Err(err);
     }
-    std::fs::remove_dir_all(path).map_err(|e| IdeError::internal(e.to_string()))
+    retrying(REMOVE_ATTEMPTS, REMOVE_PAUSE, || std::fs::remove_dir_all(path))
+        .map_err(|e| IdeError::internal(format!("{}: {e}", path.display())))
+}
+
+/// On Windows a folder can't be deleted while a process still has a file in it open
+/// (os error 32): an agent's helper that outlived it, an antivirus scan, the search indexer.
+/// Those let go within moments, so removing is retried for a few seconds.
+const REMOVE_ATTEMPTS: u32 = 10;
+const REMOVE_PAUSE: Duration = Duration::from_millis(300);
+
+fn retrying(attempts: u32, pause: Duration, mut op: impl FnMut() -> std::io::Result<()>) -> std::io::Result<()> {
+    for _ in 1..attempts {
+        match op() {
+            Err(e) if e.kind() != std::io::ErrorKind::NotFound => std::thread::sleep(pause),
+            _ => return Ok(()),
+        }
+    }
+    match op() {
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(()),
+        r => r,
+    }
 }
 
 /// Files under `cwd` that differ from `base` (untracked files included), with line counts.
@@ -149,6 +169,54 @@ fn unique_slug(base: &str, taken: impl Fn(&str) -> bool) -> String {
 mod tests {
     use super::*;
 
+    #[test]
+    fn removing_is_retried_while_a_file_is_still_in_use() {
+        use std::io::{Error, ErrorKind};
+        // A sharing violation as Windows reports it (os error 32), a vanished folder, other errors.
+        let in_use = || Error::from_raw_os_error(32);
+        for (fails, outcome) in [(0, true), (3, true), (REMOVE_ATTEMPTS - 1, true), (REMOVE_ATTEMPTS, false)] {
+            let mut calls = 0;
+            let r = retrying(REMOVE_ATTEMPTS, Duration::ZERO, || {
+                calls += 1;
+                if calls <= fails { Err(in_use()) } else { Ok(()) }
+            });
+            assert_eq!(r.is_ok(), outcome, "{fails} failures");
+            assert_eq!(calls, (fails + 1).min(REMOVE_ATTEMPTS));
+        }
+        let mut calls = 0;
+        let gone = retrying(REMOVE_ATTEMPTS, Duration::ZERO, || {
+            calls += 1;
+            if calls == 1 { Err(in_use()) } else { Err(Error::from(ErrorKind::NotFound)) }
+        });
+        assert!(gone.is_ok(), "deleted meanwhile: done");
+        assert_eq!(calls, 2);
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn removing_waits_for_a_windows_file_lock_to_be_released() {
+        use std::os::windows::fs::OpenOptionsExt;
+        let tmp = tempfile::tempdir().unwrap();
+        let repo = tmp.path().join("repo");
+        std::fs::create_dir(&repo).unwrap();
+        git(&repo, &["init", "-q", "-b", "main"]);
+        std::fs::write(repo.join("a.txt"), "one\n").unwrap();
+        git(&repo, &["add", "."]);
+        git(&repo, &["commit", "-q", "-m", "init"]);
+        let worktrees = tmp.path().join("wt");
+        let created = create(&repo, &worktrees, "Locked file", None).unwrap();
+        let file = std::fs::OpenOptions::new().read(true).share_mode(0).open(created.path.join("a.txt")).unwrap();
+        assert_eq!(std::fs::remove_file(created.path.join("a.txt")).unwrap_err().raw_os_error(), Some(32));
+        let release = std::thread::spawn(move || {
+            std::thread::sleep(Duration::from_millis(800));
+            drop(file);
+        });
+        let result = remove(&repo, &worktrees, &created.path);
+        release.join().unwrap();
+        result.unwrap();
+        assert!(!created.path.exists());
+    }
+
     #[test]
     fn slugs_are_branch_safe() {
         assert_eq!(slugify("Fix lexer UTF-16 columns!"), "fix-lexer-utf-16-columns");

crates/ide-build/src/compile/mod.rs

@@ -10,6 +10,7 @@ pub use fingerprint::{LaunchFingerprint, launch_fingerprint};
 
 use crate::process::{self, Stream};
 use crate::{BuildModel, maven};
+use ide_core::settings::CMakeProfile;
 use ide_core::{CancellationToken, Diagnostic, IdeError, IdeResult, Pos, Range, Severity};
 use parse::{ColUnit, Format, OutputParser, RawMessage};
 use serde::{Deserialize, Serialize};
@@ -41,6 +42,8 @@ pub enum BuildSystem {
     Go,
     #[serde(rename = "typescript")]
     TypeScript,
+    #[serde(rename = "cmake")]
+    CMake,
 }
 
 /// One command of a build.
@@ -152,6 +155,8 @@ fn detect_dir(dir: &Path, model: &BuildModel, root: &Path) -> Option<BuildSystem
         Some(BuildSystem::Go)
     } else if has(dir, &["tsconfig.json", "package.json"]) {
         Some(BuildSystem::TypeScript)
+    } else if has(dir, &["CMakeLists.txt"]) {
+        Some(BuildSystem::CMake)
     } else {
         None
     }
@@ -176,7 +181,14 @@ fn ancestors_within<'a>(root: &'a Path, file: &'a Path) -> impl Iterator<Item =
 }
 
 /// The build of `root`, or of the module containing `file` (Build Module / Recompile).
-pub fn plan(root: &Path, model: &BuildModel, kind: BuildKind, file: Option<&Path>) -> IdeResult<BuildPlan> {
+/// `cmake`: the CMake profiles of the settings (the first one is built), if any.
+pub fn plan(
+    root: &Path,
+    model: &BuildModel,
+    kind: BuildKind,
+    file: Option<&Path>,
+    cmake: Option<&[CMakeProfile]>,
+) -> IdeResult<BuildPlan> {
     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) => {
@@ -192,7 +204,9 @@ pub fn plan(root: &Path, model: &BuildModel, kind: BuildKind, file: Option<&Path
     let system = detect_dir(&dir, model, root)
         .or_else(|| if model.gradle.is_some() { Some(BuildSystem::Gradle) } else { None })
         .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) found"))?;
+        .ok_or_else(|| {
+            IdeError::not_found("no supported build system (Maven, Gradle, Cargo, Go, TypeScript, CMake) found")
+        })?;
     let module = module_dir.as_deref().filter(|d| *d != root);
     let title = match module {
         Some(d) => format!(
@@ -209,6 +223,7 @@ pub fn plan(root: &Path, model: &BuildModel, kind: BuildKind, file: Option<&Path
         // Go builds the file's package (a module holds many).
         BuildSystem::Go => go_steps(file.and_then(Path::parent).unwrap_or(&dir), kind),
         BuildSystem::TypeScript => ts_steps(&dir, kind),
+        BuildSystem::CMake => cmake_steps(&dir, kind, cmake.and_then(<[_]>::first)),
     };
     Ok(BuildPlan { system, title, steps })
 }
@@ -302,6 +317,50 @@ fn cargo_steps(dir: &Path, kind: BuildKind) -> Vec<BuildStep> {
     }
 }
 
+/// CLion's Build Project for a CMake project: configures the build directory when it has no
+/// `CMakeCache.txt` yet, then `cmake --build` (`--clean-first` to rebuild). The directory and
+/// options come from the CMake profile; without one, a configured directory of the project
+/// (the first by name), else `build`, as the generated run configurations use.
+fn cmake_steps(dir: &Path, kind: BuildKind, profile: Option<&CMakeProfile>) -> Vec<BuildStep> {
+    let build_dir = match profile {
+        Some(p) if !p.build_dir.trim().is_empty() => p.build_dir.trim().to_owned(),
+        Some(p) => format!("cmake-build-{}", p.build_type.to_lowercase()),
+        None => {
+            let mut configured: Vec<String> = std::fs::read_dir(dir)
+                .into_iter()
+                .flatten()
+                .flatten()
+                .filter(|e| e.path().join("CMakeCache.txt").is_file())
+                .map(|e| e.file_name().to_string_lossy().into_owned())
+                .collect();
+            configured.sort();
+            configured.into_iter().next().unwrap_or_else(|| "build".into())
+        }
+    };
+    let build_type = profile.map_or("Debug", |p| p.build_type.as_str());
+    let env = profile.map(|p| p.env.clone()).unwrap_or_default();
+    let mut steps = Vec::new();
+    if !dir.join(&build_dir).join("CMakeCache.txt").is_file() {
+        let mut configure = BuildStep::new("cmake", &["-S", ".", "-B", &build_dir], dir, Format::Gcc);
+        if let Some(p) = profile.filter(|p| !p.generator.trim().is_empty()) {
+            configure.args.extend(["-G".into(), p.generator.clone()]);
+        }
+        configure.args.push(format!("-DCMAKE_BUILD_TYPE={build_type}"));
+        configure.args.push("-DCMAKE_EXPORT_COMPILE_COMMANDS=ON".into());
+        configure.args.extend(profile.map(|p| p.cmake_args.clone()).unwrap_or_default());
+        configure.env = env.clone();
+        steps.push(configure);
+    }
+    let mut build = BuildStep::new("cmake", &["--build", &build_dir, "--config", build_type], dir, Format::Gcc);
+    if kind == BuildKind::Rebuild {
+        build.args.push("--clean-first".into());
+    }
+    build.args.extend(profile.map(|p| p.build_args.clone()).unwrap_or_default());
+    build.env = env;
+    steps.push(build);
+    steps
+}
+
 fn go_steps(dir: &Path, kind: BuildKind) -> Vec<BuildStep> {
     let module_root = dir.ancestors().find(|d| d.join("go.mod").is_file()).unwrap_or(dir);
     let target = if module_root == dir { "./...".to_owned() } else { format!("./{}/...", rel_str(module_root, dir)) };
@@ -687,7 +746,7 @@ fn launch_plan(root: &Path, model: &BuildModel, module: &Path, test: bool) -> Id
     } else {
         BuildKind::Build
     };
-    let mut plan = plan(root, model, kind, Some(module))?;
+    let mut plan = plan(root, model, kind, Some(module), None)?;
     if plan.system == BuildSystem::Maven && !test {
         for step in &mut plan.steps {
             if let Some(goal) = step.args.last_mut() {
@@ -796,12 +855,12 @@ mod tests {
         write(&root, "core/pom.xml", "<project><artifactId>core</artifactId></project>");
         write(&root, "core/src/main/java/A.java", "class A {}");
         let model = crate::load(&root, &tmp.path().join("cache"), None);
-        let p = plan(&root, &model, BuildKind::Build, None).unwrap();
+        let p = plan(&root, &model, BuildKind::Build, None, None).unwrap();
         assert_eq!(p.system, BuildSystem::Maven);
         assert_eq!(p.title, "demo");
         assert_eq!(p.steps.len(), 1);
         assert_eq!(p.steps[0].args, ["-B", "-Dstyle.color=never", "test-compile"]);
-        let p = plan(&root, &model, BuildKind::Rebuild, Some(&root.join("core/src/main/java/A.java"))).unwrap();
+        let p = plan(&root, &model, BuildKind::Rebuild, Some(&root.join("core/src/main/java/A.java")), None).unwrap();
         assert_eq!(p.steps[0].args, ["-B", "-Dstyle.color=never", "-pl", "core", "-am", "clean", "test-compile"]);
         assert_eq!(p.steps[0].cwd, root);
         assert_eq!(p.title, "demo: build module 'core'");
@@ -810,24 +869,24 @@ mod tests {
         write(&g, "settings.gradle", "include 'app'");
         write(&g, "app/build.gradle", "apply plugin: 'java'");
         let model = crate::load(&g, &tmp.path().join("cache2"), None);
-        let p = plan(&g, &model, BuildKind::Build, Some(&g.join("app/src/A.java"))).unwrap();
+        let p = plan(&g, &model, BuildKind::Build, Some(&g.join("app/src/A.java")), None).unwrap();
         assert_eq!(p.system, BuildSystem::Gradle);
         assert_eq!(p.steps[0].args, ["--console=plain", ":app:classes", ":app:testClasses"]);
         assert_eq!(
-            plan(&g, &model, BuildKind::Artifacts, None).unwrap().steps[0].args,
+            plan(&g, &model, BuildKind::Artifacts, None, None).unwrap().steps[0].args,
             ["--console=plain", "assemble"]
         );
 
         let c = tmp.path().join("c");
         write(&c, "Cargo.toml", "[package]\nname='c'");
-        let p = plan(&c, &BuildModel::default(), BuildKind::Rebuild, None).unwrap();
+        let p = plan(&c, &BuildModel::default(), BuildKind::Rebuild, None, None).unwrap();
         assert_eq!(p.system, BuildSystem::Cargo);
         assert_eq!(p.steps.len(), 2);
         assert_eq!(p.steps[0].args[0], "clean");
 
         let go = tmp.path().join("go");
         write(&go, "go.mod", "module x");
-        let p = plan(&go, &BuildModel::default(), BuildKind::Build, Some(&go.join("pkg/a/a.go"))).unwrap();
+        let p = plan(&go, &BuildModel::default(), BuildKind::Build, Some(&go.join("pkg/a/a.go")), None).unwrap();
         assert_eq!(p.steps[0].args, ["build", "./pkg/a/..."]);
         assert_eq!(p.steps[0].cwd, go);
 
@@ -835,19 +894,51 @@ mod tests {
         write(&ts, "package.json", r#"{"scripts":{"build":"vite build"}}"#);
         write(&ts, "tsconfig.json", "{}");
         write(&ts, "pnpm-lock.yaml", "");
-        let p = plan(&ts, &BuildModel::default(), BuildKind::Build, None).unwrap();
+        let p = plan(&ts, &BuildModel::default(), BuildKind::Build, None, None).unwrap();
         assert_eq!(p.steps[0].args, ["--noEmit", "--pretty", "false", "-p", "."]);
-        let p = plan(&ts, &BuildModel::default(), BuildKind::Artifacts, None).unwrap();
+        let p = plan(&ts, &BuildModel::default(), BuildKind::Artifacts, None, None).unwrap();
         assert_eq!(
             (p.steps[0].program.as_str(), p.steps[0].args.as_slice()),
             ("pnpm", &["run".to_owned(), "build".to_owned()][..])
         );
 
+        let cm = tmp.path().join("cm");
+        write(&cm, "CMakeLists.txt", "project(app)");
+        let args = |p: &BuildPlan| p.steps.iter().map(|s| s.args.join(" ")).collect::<Vec<_>>();
+        let p = plan(&cm, &BuildModel::default(), BuildKind::Build, None, None).unwrap();
+        assert_eq!(p.system, BuildSystem::CMake);
+        assert_eq!(
+            args(&p),
+            [
+                "-S . -B build -DCMAKE_BUILD_TYPE=Debug -DCMAKE_EXPORT_COMPILE_COMMANDS=ON",
+                "--build build --config Debug"
+            ],
+            "an unconfigured project is configured first"
+        );
+        write(&cm, "cmake-build-release/CMakeCache.txt", "");
+        let p = plan(&cm, &BuildModel::default(), BuildKind::Rebuild, None, None).unwrap();
+        assert_eq!(
+            args(&p),
+            ["--build cmake-build-release --config Debug --clean-first"],
+            "a configured directory is reused"
+        );
+        let profile = CMakeProfile {
+            build_type: "Release".into(),
+            generator: "Ninja".into(),
+            build_args: vec!["-j".into(), "8".into()],
+            ..CMakeProfile::default()
+        };
+        let p =
+            plan(&cm, &BuildModel::default(), BuildKind::Build, None, Some(std::slice::from_ref(&profile))).unwrap();
+        assert_eq!(args(&p), ["--build cmake-build-release --config Release -j 8"]);
+        let p = plan(&cm, &BuildModel::default(), BuildKind::Build, None, Some(&[CMakeProfile::default()])).unwrap();
+        assert_eq!(p.steps[0].args[..4], ["-S", ".", "-B", "cmake-build-debug"]);
+
         let siblings = tmp.path().join("siblings");
         write(&siblings, "core/pom.xml", "<project><artifactId>core</artifactId></project>");
         write(&siblings, "system/pom.xml", "<project><artifactId>system</artifactId></project>");
         let model = crate::load(&siblings, &tmp.path().join("cache3"), None);
-        let p = plan(&siblings, &model, BuildKind::Build, None).unwrap();
+        let p = plan(&siblings, &model, BuildKind::Build, None, None).unwrap();
         assert_eq!(p.system, BuildSystem::Maven);
         assert_eq!(
             p.steps.iter().map(|s| s.cwd.clone()).collect::<Vec<_>>(),
@@ -856,7 +947,7 @@ mod tests {
 
         let none = tmp.path().join("none");
         std::fs::create_dir_all(&none).unwrap();
-        assert!(plan(&none, &BuildModel::default(), BuildKind::Build, None).is_err());
+        assert!(plan(&none, &BuildModel::default(), BuildKind::Build, None, None).is_err());
     }
 
     #[test]

crates/ide-build/src/compile/parse.rs

@@ -22,6 +22,8 @@ pub(crate) enum Format {
     Tsc,
     /// `go build`: `./a.go:12:5: msg`.
     Go,
+    /// GCC / Clang (through `cmake --build`): `src/a.cpp:12:5: error: msg`.
+    Gcc,
 }
 
 /// What a printed column counts.
@@ -296,6 +298,17 @@ fn go_line(line: &str) -> Option<RawMessage> {
     (!msg.is_empty()).then(|| RawMessage::new(Severity::Error, msg, ColUnit::Byte).at(path, ln, col))
 }
 
+/// A GCC / Clang diagnostic line; notes and the context lines after it are left as output.
+fn gcc_line(line: &str) -> Option<RawMessage> {
+    let (path, ln, col, rest) = path_line_col(line)?;
+    let rest = rest.strip_prefix(':')?.trim_start();
+    let (severity, msg) =
+        [("fatal error:", Severity::Error), ("error:", Severity::Error), ("warning:", Severity::Warning)]
+            .into_iter()
+            .find_map(|(prefix, severity)| rest.strip_prefix(prefix).map(|m| (severity, m.trim())))?;
+    (!msg.is_empty()).then(|| RawMessage::new(severity, msg, ColUnit::Byte).at(path, ln, col))
+}
+
 /// rustc's JSON diagnostic (`reason: compiler-message`) → message and its rendered text.
 fn cargo_json(v: &Value) -> Option<(Option<RawMessage>, String)> {
     if v.get("reason")?.as_str()? != "compiler-message" {
@@ -410,6 +423,7 @@ impl OutputParser {
             Format::Gradle => javac_header(&line).or_else(|| kotlin_line(&line)),
             Format::Tsc => tsc_line(&line),
             Format::Go => go_line(&line),
+            Format::Gcc => gcc_line(&line),
             Format::Cargo => None,
         };
         if let Some(msg) = parsed {
@@ -563,6 +577,24 @@ mod tests {
         assert_eq!(out[2].text, "Cannot find name 'foo'.");
     }
 
+    #[test]
+    fn gcc_errors_and_warnings() {
+        let out = parse(
+            Format::Gcc,
+            "[1/2] Building CXX object CMakeFiles/app.dir/main.cpp.o\n\
+             /p/src/main.cpp:12:5: error: use of undeclared identifier 'foo'\n\
+             \x20  12 |     foo();\n\
+             /p/src/util.h:3:10: warning: unused variable 'x' [-Wunused-variable]\n\
+             /p/src/main.cpp:4:10: fatal error: 'missing.h' file not found\n\
+             /p/src/main.cpp:2:1: note: in file included from here\n",
+        );
+        assert_eq!(out.len(), 3, "{out:?}");
+        assert_eq!(out[0].severity, Severity::Error);
+        assert_eq!(out[0].text, "use of undeclared identifier 'foo'");
+        assert_eq!(out[1].severity, Severity::Warning);
+        assert_eq!(out[2].text, "'missing.h' file not found");
+    }
+
     #[test]
     fn go_errors() {
         let out = parse(

crates/ide-build/src/gradle-model.gradle

@@ -0,0 +1,40 @@
+// OpenIDEA Gradle sync: prints each project as Gradle evaluated it, one JSON line per project.
+// Read by `ide_build::gradle::parse_reported_projects`. Dependencies are not resolved: the
+// Java language server reads the classpath itself, and resolving is the slow part of an import.
+import groovy.json.JsonOutput
+
+def canon = { File f -> f.canonicalPath }
+// Init scripts also run in included builds and buildSrc, whose projects reuse `:`, `:core`…:
+// the identity path (`:lib:core`, `:buildSrc`) tells them apart and addresses their tasks
+// from the root build. Internal API, hence the fallback.
+def identity = { Project p -> try { p.identityPath.toString() } catch (ignored) { p.path } }
+
+def describe = { Project p ->
+    def m = [path: identity(p), dir: canon(p.projectDir), buildDir: canon(p.layout.buildDirectory.get().asFile)]
+    if (p.gradle.parent != null) m.build = identity(p.rootProject)
+    def sets = p.extensions.findByName('sourceSets')
+    if (sets != null) {
+        // Test source sets as IDEA classifies them: `test`, test fixtures, JVM test suites,
+        // and sets whose folders the `idea` plugin lists as test sources.
+        def suites = [] as Set
+        try { p.extensions.findByName('testing')?.suites?.each { suites << it.sources.name } } catch (ignored) {}
+        def ideaTests = [] as Set
+        try { p.extensions.findByName('idea')?.module?.testSources?.files?.each { ideaTests << canon(it) } } catch (ignored) {}
+        m.sourceSets = sets.collect { s ->
+            def res = s.resources.srcDirs.collect(canon)
+            def src = s.allSource.srcDirs.collect(canon) - res
+            def test = s.name == 'test' || s.name == 'testFixtures' || suites.contains(s.name) ||
+                s.name.endsWith('Test') || s.name.endsWith('Tests') ||
+                (!src.isEmpty() && src.every { ideaTests.contains(it) })
+            [name: s.name, test: test, src: src, res: res]
+        }
+    }
+    try {
+        def java = p.extensions.findByName('java')
+        def lv = java?.toolchain?.languageVersion?.getOrNull()
+        m.java = lv != null ? lv.asInt() : (java?.targetCompatibility?.majorVersion as Integer)
+    } catch (ignored) {}
+    println '@openidea-model\t' + JsonOutput.toJson(m)
+}
+
+gradle.projectsEvaluated { g -> g.rootProject.allprojects { describe(it) } }

crates/ide-build/src/gradle.rs

@@ -32,7 +32,8 @@ pub struct GradleModel {
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct GradleProject {
-    /// Gradle path: `:` for the root project, `:app`, `:libs:core`.
+    /// Gradle path: `:` for the root project, `:app`, `:libs:core`; for a project of a
+    /// nested build its identity path (`:lib:core`), which addresses its tasks from the root.
     pub path: String,
     pub name: String,
     /// Project-relative directory.
@@ -40,6 +41,10 @@ pub struct GradleProject {
     /// Project-relative build script, if any.
     pub build_file: Option<String>,
     pub tasks: Vec<GradleTask>,
+    /// Identity path of the nested build holding the project (`:lib` for `includeBuild`,
+    /// `:buildSrc`); null for the opened build.
+    #[serde(default)]
+    pub build: Option<String>,
 }
 
 #[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
@@ -129,35 +134,88 @@ fn include_args(after: &str) -> Vec<String> {
     out
 }
 
-/// `(root project name, included project paths)` from a settings script.
-pub fn parse_settings(text: &str) -> (Option<String>, Vec<String>) {
+/// What a settings script declares, read statically.
+#[derive(Debug, Default, PartialEq)]
+pub struct Settings {
+    pub name: Option<String>,
+    /// Included project paths (`:app`), in declaration order.
+    pub includes: Vec<String>,
+    /// Project directories that differ from the default `<path>` under the build
+    /// dir, relative to it: `includeFlat` siblings and literal `projectDir = file(..)`.
+    pub dirs: BTreeMap<String, String>,
+}
+
+/// The included projects, root project name and directory overrides of a settings script.
+/// Interpolated (`"$m"`) names and directories cannot be read without Gradle and are skipped.
+pub fn parse_settings(text: &str) -> Settings {
     let text = strip_comments(text);
-    let mut name = None;
-    let mut includes: Vec<String> = Vec::new();
+    let mut s = Settings::default();
     for (i, _) in text.match_indices("rootProject.name") {
         let line = text[i + "rootProject.name".len()..].lines().next().unwrap_or_default();
         if let Some(n) = literals(line).into_iter().next() {
-            name = Some(n);
+            s.name = Some(n);
         }
     }
     let mut from = 0;
     while let Some(i) = text[from..].find("include") {
         let at = from + i;
         from = at + "include".len();
+        let flat = text[from..].starts_with("Flat");
+        if flat {
+            from += "Flat".len();
+        }
         let before_ok = at == 0 || !text[..at].ends_with(|c: char| c.is_alphanumeric() || c == '_' || c == '.');
         let after = &text[from..];
         let after_ok = after.starts_with(|c: char| c == '(' || c.is_whitespace());
         if !before_ok || !after_ok {
             continue;
         }
-        for p in include_args(after) {
+        for p in include_args(after).into_iter().filter(|p| !p.contains('$')) {
             let path = if p.starts_with(':') { p } else { format!(":{p}") };
-            if path.len() > 1 && !includes.contains(&path) {
-                includes.push(path);
+            if path.len() <= 1 {
+                continue;
+            }
+            // `includeFlat 'a'` is the sibling directory `../a` of the root project.
+            if flat {
+                s.dirs.insert(path.clone(), format!("../{}", path.trim_start_matches(':')));
+            }
+            if !s.includes.contains(&path) {
+                s.includes.push(path);
             }
         }
     }
-    (name, includes)
+    // `project(':a').projectDir = file('../a')`; a later assignment wins, as in Gradle.
+    for line in text.lines() {
+        let Some((left, right)) = line.split_once(".projectDir") else { continue };
+        let Some(right) = right.trim_start().strip_prefix('=') else { continue };
+        let Some(arg) = right.trim_start().strip_prefix("file") else { continue };
+        let (Some(path), Some(dir)) = (
+            left.rsplit_once("project").map(|(_, p)| literals(p)).and_then(|l| l.into_iter().next()),
+            literals(arg).into_iter().next(),
+        ) else {
+            continue;
+        };
+        if !path.contains('$') && !dir.contains('$') {
+            let path = if path.starts_with(':') { path } else { format!(":{path}") };
+            s.dirs.insert(path, dir);
+        }
+    }
+    s
+}
+
+/// `a/b/../c` → `a/c`, without touching the filesystem.
+fn normalize(p: &Path) -> PathBuf {
+    let mut out = PathBuf::new();
+    for c in p.components() {
+        match c {
+            std::path::Component::CurDir => {}
+            std::path::Component::ParentDir if out.file_name().is_some() => {
+                out.pop();
+            }
+            c => out.push(c),
+        }
+    }
+    out
 }
 
 /// The directory of the Gradle build under `root`: the root itself, or a direct
@@ -235,31 +293,159 @@ pub fn default_tasks(is_root: bool, script: &str) -> Vec<GradleTask> {
 }
 
 /// Reads the Gradle build under `root` (no Gradle run), or `None` when there is none.
+fn read_first(d: &Path, names: &[&str]) -> Option<(String, String)> {
+    names.iter().find_map(|n| std::fs::read_to_string(d.join(n)).ok().map(|t| (n.to_string(), t)))
+}
+
+/// The project `path` in `pdir`, with the default tasks of its build script.
+/// Outside `root` the directory stays absolute (`rel` falls back).
+fn project_at(root: &Path, path: String, name: String, pdir: &Path) -> GradleProject {
+    let script = read_first(pdir, BUILD_FILES);
+    let tasks = default_tasks(path == ":", script.as_ref().map(|(_, t)| t.as_str()).unwrap_or_default());
+    GradleProject {
+        build_file: script.map(|(n, _)| rel(root, &pdir.join(n))),
+        dir: rel(root, pdir),
+        path,
+        name,
+        tasks,
+        build: None,
+    }
+}
+
+/// A project as Gradle evaluated it (the sync's init script, `gradle-model.gradle`).
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ReportedProject {
+    pub path: String,
+    /// Absolute, canonical.
+    pub dir: String,
+    /// Absolute output folder (`layout.buildDirectory`).
+    #[serde(default)]
+    pub build_dir: Option<String>,
+    #[serde(default)]
+    pub source_sets: Vec<ReportedSourceSet>,
+    /// Toolchain language version, else target compatibility.
+    #[serde(default)]
+    pub java: Option<u32>,
+    /// Identity path of the nested build (included build, buildSrc) reporting the project.
+    #[serde(default)]
+    pub build: Option<String>,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+pub struct ReportedSourceSet {
+    pub name: String,
+    pub test: bool,
+    /// Absolute source folders (Java, Kotlin, Groovy, …), which need not exist.
+    #[serde(default)]
+    pub src: Vec<String>,
+    /// Absolute resource folders.
+    #[serde(default)]
+    pub res: Vec<String>,
+}
+
+const MODEL_LINE: &str = "@openidea-model\t";
+
+/// The projects printed by `gradle-model.gradle`; malformed lines are skipped.
+pub fn parse_reported_projects(output: &str) -> Vec<ReportedProject> {
+    output.lines().filter_map(|l| serde_json::from_str(l.trim_end().strip_prefix(MODEL_LINE)?).ok()).collect()
+}
+
+/// Source roots of the reported source sets: `(absolute folder, is test, is resources)`.
+pub fn reported_source_roots(reported: &[ReportedProject]) -> Vec<(PathBuf, ReportedRoot)> {
+    let mut out: Vec<(PathBuf, ReportedRoot)> = Vec::new();
+    for p in reported {
+        for set in &p.source_sets {
+            let (src, res) = if set.test {
+                (ReportedRoot::Test, ReportedRoot::TestResources)
+            } else {
+                (ReportedRoot::Source, ReportedRoot::Resources)
+            };
+            for (dir, kind) in set.src.iter().map(|d| (d, src)).chain(set.res.iter().map(|d| (d, res))) {
+                let dir = PathBuf::from(dir);
+                // A folder shared by `main` and another set is `main`'s, as in IDEA.
+                if !out.iter().any(|(d, _)| *d == dir) {
+                    out.push((dir, kind));
+                }
+            }
+        }
+        // IDEA excludes the build folder of every module.
+        if let Some(b) = &p.build_dir {
+            out.push((PathBuf::from(b), ReportedRoot::Excluded));
+        }
+    }
+    out
+}
+
+/// Role of a folder a Gradle sync reported.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ReportedRoot {
+    Source,
+    Test,
+    Resources,
+    TestResources,
+    Excluded,
+}
+
+/// Replaces the statically read projects with the ones Gradle reported (root first):
+/// settings scripts may compute their projects, which no static reading sees.
+pub fn merge_reported_projects(root: &Path, model: &mut GradleModel, reported: &[ReportedProject]) {
+    if reported.is_empty() {
+        return;
+    }
+    let root_name = model.projects.iter().find(|p| p.path == ":").map(|p| p.name.clone());
+    model.projects = reported
+        .iter()
+        .map(|p| {
+            let name = match p.path.as_str() {
+                ":" => root_name.clone().unwrap_or_default(),
+                path => path.rsplit(':').next().unwrap_or_default().to_owned(),
+            };
+            let mut project = project_at(root, p.path.clone(), name, Path::new(&p.dir));
+            // buildSrc is built before the build, never addressable as `:buildSrc:<task>`.
+            if p.build.as_deref().is_some_and(|b| b.ends_with(":buildSrc")) {
+                project.tasks.clear();
+            }
+            project.build = p.build.clone();
+            project
+        })
+        .collect();
+    // Each build reports its projects when it is evaluated (nested builds first).
+    model.projects.sort_by(|a, b| a.path.cmp(&b.path));
+    // One JDK runs the whole build: the newest any module needs.
+    if let Some(v) = reported.iter().filter_map(|p| p.java).max() {
+        model.java_version = Some(v);
+    }
+}
+
+/// Project directories outside `root`, outermost only (`../svc`, not also `../svc/sources/app`):
+/// the folders IDEA shows as extra top-level module roots.
+pub fn external_roots<'a>(root: &Path, dirs: impl IntoIterator<Item = &'a str>) -> Vec<PathBuf> {
+    let mut dirs: Vec<PathBuf> = dirs.into_iter().map(|d| root.join(d)).filter(|d| !d.starts_with(root)).collect();
+    dirs.sort();
+    dirs.dedup();
+    let mut out: Vec<PathBuf> = Vec::new();
+    for d in dirs {
+        if !out.iter().any(|o| d.starts_with(o)) {
+            out.push(d);
+        }
+    }
+    out
+}
+
 pub fn load(root: &Path) -> Option<GradleModel> {
     let dir = build_dir(root)?;
-    let read = |d: &Path, names: &[&str]| {
-        names.iter().find_map(|n| std::fs::read_to_string(d.join(n)).ok().map(|t| (n.to_string(), t)))
-    };
-    let (name, includes) = read(&dir, SETTINGS_FILES).map(|(_, t)| parse_settings(&t)).unwrap_or_default();
+    let settings = read_first(&dir, SETTINGS_FILES).map(|(_, t)| parse_settings(&t)).unwrap_or_default();
     let root_name =
-        name.unwrap_or_else(|| dir.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default());
-    let mut projects = Vec::new();
-    let mut add = |path: String, name: String, pdir: PathBuf| {
-        let script = read(&pdir, BUILD_FILES);
-        let tasks = default_tasks(path == ":", script.as_ref().map(|(_, t)| t.as_str()).unwrap_or_default());
-        projects.push(GradleProject {
-            build_file: script.map(|(n, _)| rel(root, &pdir.join(n))),
-            dir: rel(root, &pdir),
-            path,
-            name,
-            tasks,
-        });
-    };
-    add(":".into(), root_name, dir.clone());
-    for path in includes {
-        let pdir = dir.join(path.trim_start_matches(':').replace(':', "/"));
+        settings.name.unwrap_or_else(|| dir.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default());
+    let mut projects = vec![project_at(root, ":".into(), root_name, &dir)];
+    for path in settings.includes {
+        let pdir = match settings.dirs.get(&path) {
+            Some(d) => normalize(&dir.join(d)),
+            None => dir.join(path.trim_start_matches(':').replace(':', "/")),
+        };
         let name = path.rsplit(':').next().unwrap_or_default().to_owned();
-        add(path, name, pdir);
+        projects.push(project_at(root, path, name, &pdir));
     }
     let java_version = projects
         .iter()
@@ -358,9 +544,32 @@ pub fn build_files(root: &Path, model: &GradleModel) -> Vec<PathBuf> {
     let dir = root.join(&model.dir);
     let mut out: Vec<PathBuf> = SETTINGS_FILES.iter().map(|f| dir.join(f)).filter(|p| p.is_file()).collect();
     out.extend(model.projects.iter().filter_map(|p| p.build_file.as_ref().map(|f| root.join(f))));
+    // The settings of each nested build (its root project's folder).
+    for p in model.projects.iter().filter(|p| p.build.as_deref() == Some(p.path.as_str())) {
+        let nested = root.join(&p.dir);
+        out.extend(SETTINGS_FILES.iter().map(|f| nested.join(f)).filter(|f| f.is_file()));
+    }
+    // What IDEA's auto-import also watches: properties, the wrapper and version catalogs.
+    let extra = ["gradle.properties", "gradle/wrapper/gradle-wrapper.properties"].map(|f| dir.join(f));
+    out.extend(extra.into_iter().filter(|p| p.is_file()));
+    if let Ok(entries) = std::fs::read_dir(dir.join("gradle")) {
+        let mut catalogs: Vec<PathBuf> = entries
+            .flatten()
+            .map(|e| e.path())
+            .filter(|p| p.to_string_lossy().ends_with(".versions.toml") && p.is_file())
+            .collect();
+        catalogs.sort();
+        out.extend(catalogs);
+    }
     out
 }
 
+/// A build script without comments and with whitespace runs collapsed, so editing a
+/// comment or reformatting does not make a sync stale (IDEA hashes lexer tokens alike).
+pub(crate) fn script_fingerprint(text: &str) -> String {
+    strip_comments(text).split_whitespace().collect::<Vec<_>>().join(" ")
+}
+
 /// `(project path, task)` from `gradle tasks --all` console output; tasks listed as
 /// `app:run` belong to `:app`, unqualified ones to the root project `:`.
 pub fn parse_tasks(output: &str) -> Vec<(String, GradleTask)> {
@@ -451,14 +660,60 @@ dependencies {
             /* include("block") */
             includeBuild("plugins")
         "#;
-        let (name, includes) = parse_settings(kts);
-        assert_eq!(name.as_deref(), Some("gradle-demo"));
-        assert_eq!(includes, [":app", ":lib", ":libs:core"]);
+        let s = parse_settings(kts);
+        assert_eq!(s.name.as_deref(), Some("gradle-demo"));
+        assert_eq!(s.includes, [":app", ":lib", ":libs:core"]);
+        assert!(s.dirs.is_empty());
 
         let groovy = "rootProject.name = 'demo'\ninclude 'a',\n        'b'\ninclude ':c'\nprintln 'x'\n";
-        let (name, includes) = parse_settings(groovy);
-        assert_eq!(name.as_deref(), Some("demo"));
-        assert_eq!(includes, [":a", ":b", ":c"]);
+        let s = parse_settings(groovy);
+        assert_eq!(s.name.as_deref(), Some("demo"));
+        assert_eq!(s.includes, [":a", ":b", ":c"]);
+    }
+
+    #[test]
+    fn settings_include_flat_and_project_dirs() {
+        let groovy = r#"
+            includeFlat 'svc-a'
+            includeFlat 'svc-b', 'svc-c' // trailing comment
+            ['x', 'y'].each { m -> include ":svc-a:$m" }
+            include ':wo'
+            project(':wo').projectDir = file('../svc-a/.worktrees/wo')
+            project(":dyn").projectDir = file("${rootDir}/dyn")
+            includeFlated 'not-a-call'
+        "#;
+        let s = parse_settings(groovy);
+        assert_eq!(s.includes, [":svc-a", ":svc-b", ":svc-c", ":wo"]);
+        assert_eq!(
+            s.dirs.into_iter().collect::<Vec<_>>(),
+            [
+                (":svc-a".into(), "../svc-a".into()),
+                (":svc-b".into(), "../svc-b".into()),
+                (":svc-c".into(), "../svc-c".into()),
+                (":wo".into(), "../svc-a/.worktrees/wo".into()),
+            ]
+        );
+
+        let kts = "includeFlat(\"k\")\nproject(\":k\").projectDir = file(\"../other\")";
+        let s = parse_settings(kts);
+        assert_eq!(s.includes, [":k"]);
+        assert_eq!(s.dirs.get(":k").map(String::as_str), Some("../other"));
+    }
+
+    #[test]
+    fn loads_include_flat_siblings() {
+        let tmp = tempfile::tempdir().unwrap();
+        let ws = tmp.path();
+        std::fs::create_dir_all(ws.join("root")).unwrap();
+        std::fs::create_dir_all(ws.join("svc")).unwrap();
+        std::fs::write(ws.join("root/settings.gradle"), "rootProject.name = 'Root'\nincludeFlat 'svc'").unwrap();
+        std::fs::write(ws.join("svc/build.gradle"), "plugins { id 'java' }").unwrap();
+        let root = ws.join("root");
+        let m = load(&root).unwrap();
+        let svc = m.projects.iter().find(|p| p.path == ":svc").unwrap();
+        assert_eq!(Path::new(&svc.dir), ws.join("svc"));
+        assert_eq!(svc.build_file.as_deref().map(Path::new), Some(ws.join("svc/build.gradle").as_path()));
+        assert!(root.join(svc.build_file.as_ref().unwrap()).is_file());
     }
 
     #[test]
@@ -539,4 +794,52 @@ Pattern: clean<TaskName>: Cleans the output files of a task.
         let none = tempfile::tempdir().unwrap();
         assert!(load(none.path()).is_none());
     }
+
+    #[test]
+    fn merges_included_builds_and_build_src_by_identity_path() {
+        let tmp = tempfile::tempdir().unwrap();
+        let ws = tmp.path();
+        for d in ["shop/app", "shop/buildSrc", "lib/core"] {
+            std::fs::create_dir_all(ws.join(d)).unwrap();
+        }
+        std::fs::write(ws.join("shop/settings.gradle"), "rootProject.name = 'shop'\ninclude 'app'").unwrap();
+        std::fs::write(ws.join("lib/settings.gradle"), "include 'core'").unwrap();
+        let root = ws.join("shop");
+        // In evaluation order, as the init script prints it: nested builds first.
+        let line = |path: &str, d: &str, build: Option<&str>| {
+            let project = ReportedProject {
+                path: path.into(),
+                dir: ws.join(d).to_string_lossy().into_owned(),
+                build: build.map(Into::into),
+                ..ReportedProject::default()
+            };
+            format!("{MODEL_LINE}{}\n", serde_json::to_string(&project).unwrap())
+        };
+        let out = [
+            line(":lib", "lib", Some(":lib")),
+            line(":lib:core", "lib/core", Some(":lib")),
+            line(":buildSrc", "shop/buildSrc", Some(":buildSrc")),
+            line(":", "shop", None),
+            line(":app", "shop/app", None),
+        ]
+        .concat();
+        let mut model = load(&root).unwrap();
+        merge_reported_projects(&root, &mut model, &parse_reported_projects(&out));
+        let projects: Vec<_> =
+            model.projects.iter().map(|p| (p.path.as_str(), p.name.as_str(), p.build.as_deref())).collect();
+        assert_eq!(
+            projects,
+            [
+                (":", "shop", None),
+                (":app", "app", None),
+                (":buildSrc", "buildSrc", Some(":buildSrc")),
+                (":lib", "lib", Some(":lib")),
+                (":lib:core", "core", Some(":lib")),
+            ]
+        );
+        let build_src = &model.projects[2];
+        assert!(build_src.tasks.is_empty(), "buildSrc tasks cannot run from the root build");
+        assert!(!model.projects[4].tasks.is_empty());
+        assert!(build_files(&root, &model).contains(&ws.join("lib/settings.gradle")));
+    }
 }

crates/ide-build/src/gradle_deps.rs

@@ -0,0 +1,257 @@
+//! A Gradle project's resolved dependencies for the Dependency Analyzer:
+//! `gradle <project>:dependencies --configuration <name>`, parsed from its tree report.
+
+use crate::gradle;
+use crate::process;
+use crate::sync::{SyncOptions, error_summary};
+use ide_core::{CancellationToken, IdeError, IdeResult};
+use serde::{Deserialize, Serialize};
+use specta::Type;
+use std::path::Path;
+
+/// One line of the report: an occurrence of a dependency where it is requested.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct GradleDependency {
+    /// `group`, empty for a project dependency.
+    pub group: String,
+    /// Artifact name, or the project path (`:core`) of a project dependency.
+    pub name: String,
+    /// The version asked for here; `None` when a platform or constraint supplies it.
+    pub requested: Option<String>,
+    /// The version Gradle selected (`-> 1.2`), when it differs from the request.
+    pub selected: Option<String>,
+    /// A project of the build (`project :core`, or a module substituted by one).
+    pub project: bool,
+    /// `(*)`: listed with its dependencies earlier in the tree.
+    pub repeated: bool,
+    /// `(c)`: a dependency constraint rather than a dependency.
+    pub constraint: bool,
+    /// `(n)` / `FAILED`: not resolved.
+    pub unresolved: bool,
+    pub children: Vec<GradleDependency>,
+}
+
+/// Parses the tree of a `dependencies --configuration` report (lines `+--- g:a:1.0 -> 1.1 (*)`).
+pub fn parse_report(output: &str) -> Vec<GradleDependency> {
+    let mut roots: Vec<GradleDependency> = Vec::new();
+    // Path of child indexes from the roots to the last node of each depth.
+    let mut path: Vec<usize> = Vec::new();
+    for line in output.lines() {
+        let Some((depth, text)) = tree_line(line) else { continue };
+        let node = parse_entry(text);
+        path.truncate(depth);
+        if depth > path.len() {
+            continue; // A line deeper than its parent allows: not part of a well-formed tree.
+        }
+        let siblings = if depth == 0 {
+            &mut roots
+        } else {
+            let mut list = &mut roots;
+            for &i in &path[..depth - 1] {
+                list = &mut list[i].children;
+            }
+            let Some(parent) = list.get_mut(path[depth - 1]) else { continue };
+            &mut parent.children
+        };
+        siblings.push(node);
+        path.push(siblings.len() - 1);
+    }
+    roots
+}
+
+/// `|    \--- g:a:1.0` → (1, "g:a:1.0").
+fn tree_line(line: &str) -> Option<(usize, &str)> {
+    let mut rest = line;
+    let mut depth = 0;
+    loop {
+        if let Some(r) = rest.strip_prefix("+--- ").or_else(|| rest.strip_prefix("\\--- ")) {
+            return Some((depth, r.trim()));
+        }
+        rest = rest.strip_prefix("|    ").or_else(|| rest.strip_prefix("     "))?;
+        depth += 1;
+    }
+}
+
+fn parse_entry(text: &str) -> GradleDependency {
+    let mut d = GradleDependency::default();
+    let mut text = text.trim();
+    loop {
+        if let Some(t) = text.strip_suffix(" (*)") {
+            d.repeated = true;
+            text = t;
+        } else if let Some(t) = text.strip_suffix(" (c)") {
+            d.constraint = true;
+            text = t;
+        } else if let Some(t) = text.strip_suffix(" (n)").or_else(|| text.strip_suffix(" FAILED")) {
+            d.unresolved = true;
+            text = t;
+        } else {
+            break;
+        }
+        text = text.trim_end();
+    }
+    let (left, right) = match text.split_once(" -> ") {
+        Some((l, r)) => (l.trim(), Some(r.trim())),
+        None => (text, None),
+    };
+    if let Some(project) = left.strip_prefix("project ") {
+        d.project = true;
+        d.name = project_path(project);
+    } else {
+        let mut parts = left.splitn(3, ':');
+        d.group = parts.next().unwrap_or_default().to_owned();
+        d.name = parts.next().unwrap_or_default().to_owned();
+        d.requested = parts.next().filter(|v| !v.is_empty()).map(str::to_owned);
+    }
+    if let Some(right) = right {
+        if let Some(project) = right.strip_prefix("project ") {
+            // A module substituted by a project of the build.
+            d.project = true;
+            d.selected = Some(project_path(project));
+        } else {
+            d.selected = Some(right.to_owned());
+        }
+    }
+    d
+}
+
+/// `:core`, or `':core'` as Gradle 9 quotes it.
+fn project_path(text: &str) -> String {
+    let t = text.trim();
+    t.strip_prefix('\'').and_then(|t| t.strip_suffix('\'')).unwrap_or(t).to_owned()
+}
+
+/// Runs the `dependencies` report of `project` (a Gradle path, `:` for the root) for
+/// `configuration` and returns its tree.
+pub fn gradle_dependencies(
+    root: &Path,
+    options: &SyncOptions,
+    project: &str,
+    configuration: &str,
+    cancel: &CancellationToken,
+) -> IdeResult<Vec<GradleDependency>> {
+    if !configuration.chars().all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-') || configuration.is_empty() {
+        return Err(IdeError::invalid(format!("not a configuration name: {configuration}")));
+    }
+    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()];
+    if options.offline {
+        args.push("--offline".into());
+    }
+    let out = process::run(
+        options.gradle_command.as_deref().unwrap_or(&model.command),
+        &args,
+        &root.join(&model.dir),
+        &options.env,
+        cancel,
+        |_, _| {},
+    )?;
+    if !out.success {
+        return Err(IdeError::unavailable(error_summary(&out.text)));
+    }
+    Ok(parse_report(&out.text))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn dep(group: &str, name: &str, requested: Option<&str>) -> GradleDependency {
+        GradleDependency {
+            group: group.into(),
+            name: name.into(),
+            requested: requested.map(Into::into),
+            ..Default::default()
+        }
+    }
+
+    #[test]
+    fn parses_the_tree_with_selected_versions_and_markers() {
+        let report = "\
+------------------------------------------------------------
+Project ':app'
+------------------------------------------------------------
+
+runtimeClasspath - Runtime classpath of source set 'main'.
++--- org.springframework.boot:spring-boot-starter-web -> 3.2.0
+|    +--- org.springframework.boot:spring-boot-starter:3.2.0
+|    |    \\--- org.yaml:snakeyaml:2.2
+|    \\--- com.fasterxml.jackson.core:jackson-databind:2.15.0 -> 2.15.3 (*)
++--- project ':core'
+|    \\--- com.google.guava:guava:{strictly 32.1.3-jre} -> 32.1.3-jre (c)
++--- org.example:legacy:1.0 -> project :legacy
+\\--- org.missing:gone:9 FAILED
+
+(c) - A dependency constraint, not a dependency. The dependency affected by the constraint occurs elsewhere in the tree.
+(*) - Indicates repeated occurrences of a transitive dependency subtree. Gradle expands transitive dependency subtrees only once per project; repeat occurrences only display the root of the subtree, followed by this annotation.
+";
+        let tree = parse_report(report);
+        assert_eq!(tree.len(), 4);
+        let web = &tree[0];
+        assert_eq!((web.group.as_str(), web.name.as_str()), ("org.springframework.boot", "spring-boot-starter-web"));
+        assert_eq!((web.requested.as_deref(), web.selected.as_deref()), (None, Some("3.2.0")));
+        assert_eq!(web.children.len(), 2);
+        assert_eq!(web.children[0].children, vec![dep("org.yaml", "snakeyaml", Some("2.2"))]);
+        let databind = &web.children[1];
+        assert_eq!((databind.requested.as_deref(), databind.selected.as_deref()), (Some("2.15.0"), Some("2.15.3")));
+        assert!(databind.repeated);
+        let core = &tree[1];
+        assert!(core.project && core.group.is_empty());
+        assert_eq!(core.name, ":core");
+        let guava = &core.children[0];
+        assert!(guava.constraint);
+        assert_eq!(guava.requested.as_deref(), Some("{strictly 32.1.3-jre}"));
+        let legacy = &tree[2];
+        assert!(legacy.project);
+        assert_eq!((legacy.name.as_str(), legacy.selected.as_deref()), ("legacy", Some(":legacy")));
+        assert!(tree[3].unresolved);
+        assert_eq!(tree[3].requested.as_deref(), Some("9"));
+    }
+
+    #[test]
+    fn an_empty_configuration_has_no_dependencies() {
+        assert!(
+            parse_report("compileClasspath - Compile classpath for source set 'main'.\nNo dependencies\n").is_empty()
+        );
+    }
+
+    #[test]
+    fn rejects_names_that_are_not_configurations_or_projects() {
+        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());
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn runs_the_report_of_the_project_and_configuration() {
+        use std::os::unix::fs::PermissionsExt;
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        std::fs::write(root.join("settings.gradle"), "include 'app'").unwrap();
+        std::fs::write(root.join("build.gradle"), "").unwrap();
+        let launcher = root.join("fake-gradle");
+        std::fs::write(&launcher, "#!/bin/sh\necho \"$@\" > args\necho '\\--- org.a:b:1.0'\n").unwrap();
+        std::fs::set_permissions(&launcher, std::fs::Permissions::from_mode(0o755)).unwrap();
+        let options = SyncOptions {
+            gradle_command: Some(launcher.to_string_lossy().into_owned()),
+            offline: true,
+            ..Default::default()
+        };
+        let tree =
+            gradle_dependencies(root, &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(),
+            "--console=plain -q :app:dependencies --configuration testRuntimeClasspath --offline"
+        );
+    }
+}

crates/ide-build/src/kotlin_bridge.rs

@@ -81,7 +81,7 @@ pub fn build(
     cancel: &CancellationToken,
 ) -> IdeResult<Outcome> {
     std::fs::create_dir_all(generation)?;
-    let mut plan = compile::plan(root, model, BuildKind::Build, None)?;
+    let mut plan = compile::plan(root, model, BuildKind::Build, None, None)?;
     if plan.system != compile::BuildSystem::Maven {
         return Err(IdeError::invalid("Kotlin bridge requires a Maven build root"));
     }

crates/ide-build/src/lib.rs

@@ -8,6 +8,7 @@
 pub mod application_update;
 pub mod compile;
 pub mod gradle;
+mod gradle_deps;
 pub mod kotlin_bridge;
 pub mod maven;
 pub mod pom_edit;
@@ -17,6 +18,7 @@ pub mod web;
 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};
 
@@ -53,7 +55,8 @@ pub fn load_linked(
     settings: &ide_core::settings::MavenSettings,
 ) -> BuildModel {
     let maven = maven::is_maven_project(root).then(|| {
-        let mut m = maven::load_with_repo(root, maven_repo.or_else(maven::default_local_repo));
+        let profiles = sync::maven_profiles(cache_dir);
+        let mut m = maven::load_with(root, maven_repo.or_else(maven::default_local_repo), &profiles);
         maven::UnlinkedProjects::from_model(&m, settings).filter(&mut m);
         sync::apply_maven_cache(root, cache_dir, &mut m);
         m
@@ -65,6 +68,18 @@ pub fn load_linked(
     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()))
+}
+
+/// 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))
+}
+
 /// A library the project depends on, as `groupId:artifactId:version`.
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct DependencyCoordinate {

crates/ide-build/src/maven.rs

@@ -245,7 +245,8 @@ struct RawPom {
     plugins: Vec<RawPlugin>,
     managed_plugins: Vec<RawPlugin>,
     profiles: Vec<RawProfile>,
-    /// `<build><plugins>` `maven-compiler-plugin` `<release>` / `<source>`.
+    /// `maven-compiler-plugin` `<release>` / `<source>` of `<build><plugins>`, else of
+    /// `<pluginManagement>`.
     compiler_release: Option<String>,
 }
 
@@ -300,6 +301,16 @@ fn read_build(e: &Element, plugins: &mut Vec<RawPlugin>, managed: &mut Vec<RawPl
     managed.extend(e.list("build/pluginManagement/plugins", "plugin").into_iter().filter_map(read_plugin));
 }
 
+/// `maven-compiler-plugin` `<release>` / `<source>` among the plugins at `path`.
+fn compiler_level(project: &Element, path: &str) -> Option<String> {
+    project
+        .list(path, "plugin")
+        .into_iter()
+        .find(|p| p.text_of("artifactId").as_deref() == Some("maven-compiler-plugin"))
+        .and_then(|p| p.child("configuration"))
+        .and_then(|c| c.text_of("release").or_else(|| c.text_of("source")))
+}
+
 fn read_raw(project: &Element) -> RawPom {
     let parent = project.child("parent").and_then(|p| {
         Some(ParentRef {
@@ -328,13 +339,8 @@ fn read_raw(project: &Element) -> RawPom {
         ..RawPom::default()
     };
     read_build(project, &mut pom.plugins, &mut pom.managed_plugins);
-    if let Some(c) = pom.plugins.iter().position(|p| p.artifact_id == "maven-compiler-plugin") {
-        let plugin =
-            project.list("build/plugins", "plugin").into_iter().filter(|p| p.text_of("artifactId").is_some()).nth(c);
-        if let Some(cfg) = plugin.and_then(|p| p.child("configuration")) {
-            pom.compiler_release = cfg.text_of("release").or_else(|| cfg.text_of("source"));
-        }
-    }
+    pom.compiler_release =
+        compiler_level(project, "build/plugins").or_else(|| compiler_level(project, "build/pluginManagement/plugins"));
     for p in project.list("profiles", "profile") {
         let mut profile = RawProfile {
             id: p.text_of("id").unwrap_or_else(|| "default".into()),
@@ -411,6 +417,9 @@ struct Inherited {
     managed: Vec<RawDep>,
     plugins: Vec<RawPlugin>,
     managed_plugins: Vec<RawPlugin>,
+    /// The nearest `maven-compiler-plugin` `<release>` / `<source>`: a module usually
+    /// inherits its compiler level from the parent's (managed) plugin configuration.
+    compiler_release: Option<String>,
     /// `<id>`, `activeByDefault`: profiles of the POM and its ancestors —
     /// Maven lets a child enable a parent's profiles with `-P`.
     profiles: Vec<(String, bool)>,
@@ -451,6 +460,8 @@ const MAX_PARENT_DEPTH: usize = 10;
 
 struct Resolver {
     local_repo: Option<PathBuf>,
+    /// The chosen profiles (`-P` entries; `!id` / `-id` deactivates).
+    profiles: Vec<String>,
     poms: HashMap<PathBuf, Option<RawPom>>,
     contexts: HashMap<PathBuf, Inherited>,
 }
@@ -475,8 +486,16 @@ pub fn local_repository_of(settings: &Path) -> Option<PathBuf> {
 }
 
 impl Resolver {
-    fn new(local_repo: Option<PathBuf>) -> Self {
-        Self { local_repo, poms: HashMap::new(), contexts: HashMap::new() }
+    fn new(local_repo: Option<PathBuf>, profiles: &[String]) -> Self {
+        Self { local_repo, profiles: profiles.to_vec(), poms: HashMap::new(), contexts: HashMap::new() }
+    }
+
+    /// The active profiles of a POM: the chosen ones, and the `activeByDefault` ones not turned
+    /// off while none of the POM's other profiles is chosen (Maven's rule).
+    fn active<'a>(&self, profiles: &'a [RawProfile]) -> impl Iterator<Item = &'a RawProfile> {
+        let chosen = |id: &str| profile_choice(&self.profiles, id);
+        let any_chosen = profiles.iter().any(|p| chosen(&p.id) == Some(true));
+        profiles.iter().filter(move |p| chosen(&p.id).unwrap_or(p.active_by_default && !any_chosen))
     }
 
     fn pom(&mut self, path: &Path) -> Option<RawPom> {
@@ -538,7 +557,10 @@ impl Resolver {
         merge_by(&mut ctx.deps, &pom.deps, RawDep::key);
         merge_plugins(&mut ctx.plugins, &pom.plugins);
         merge_plugins(&mut ctx.managed_plugins, &pom.managed_plugins);
-        for p in pom.profiles.iter().filter(|p| p.active_by_default) {
+        if pom.compiler_release.is_some() {
+            ctx.compiler_release = pom.compiler_release.clone();
+        }
+        for p in self.active(&pom.profiles) {
             merge_by(&mut ctx.properties, &p.properties, |(k, _)| k.clone());
             merge_by(&mut ctx.deps, &p.deps, RawDep::key);
             merge_plugins(&mut ctx.plugins, &p.plugins);
@@ -654,7 +676,7 @@ pub(crate) fn launch_inputs(
         }
         Some(())
     }
-    let mut resolver = Resolver::new(local_repo.or_else(default_local_repo));
+    let mut resolver = Resolver::new(local_repo.or_else(default_local_repo), &[]);
     let mut out = Vec::new();
     for project in projects {
         let dir = root.join(&project.dir);
@@ -1043,8 +1065,32 @@ 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)
+}
+
 pub(crate) fn load_with_repo(root: &Path, local_repo: Option<PathBuf>) -> MavenModel {
-    let mut resolver = Resolver::new(local_repo);
+    load_with(root, local_repo, &[])
+}
+
+/// The `-P` entries' choice for profile `id`: on, off (`!id` / `-id`), or none (the last wins).
+fn profile_choice(chosen: &[String], id: &str) -> Option<bool> {
+    chosen.iter().rev().find_map(|c| {
+        let c = c.trim();
+        if c == id {
+            Some(true)
+        } else if c.strip_prefix('!').or_else(|| c.strip_prefix('-')) == Some(id) {
+            Some(false)
+        } else {
+            None
+        }
+    })
+}
+
+pub(crate) fn load_with(root: &Path, local_repo: Option<PathBuf>, profiles: &[String]) -> MavenModel {
+    let mut resolver = Resolver::new(local_repo, profiles);
     let mut model = MavenModel::default();
     let mut seen: HashSet<PathBuf> = HashSet::new();
     // (pom, aggregated)
@@ -1064,7 +1110,7 @@ pub(crate) fn load_with_repo(root: &Path, local_repo: Option<PathBuf>) -> MavenM
         let i = |s: &str| interpolate(s, &props);
 
         let mut module_names: Vec<String> = pom.modules.clone();
-        for p in pom.profiles.iter().filter(|p| p.active_by_default) {
+        for p in resolver.active(&pom.profiles) {
             module_names.extend(p.modules.iter().cloned());
         }
         let mut modules: Vec<PathBuf> = Vec::new();
@@ -1123,7 +1169,7 @@ pub(crate) fn load_with_repo(root: &Path, local_repo: Option<PathBuf>) -> MavenM
         let jv = ["maven.compiler.release", "java.version", "maven.compiler.source", "maven.compiler.target"]
             .iter()
             .find_map(|k| props.get(*k).map(|v| i(v)))
-            .or_else(|| pom.compiler_release.as_deref().map(i))
+            .or_else(|| ctx.compiler_release.as_deref().map(i))
             .and_then(|v| java_version(&v));
 
         // The project can activate the profiles of its own POM and its ancestors'.
@@ -1196,6 +1242,40 @@ impl UnlinkedProjects {
         self.poms.iter().map(String::as_str)
     }
 
+    /// The POMs the Java language server should import when an unlinked POM is a module of a
+    /// linked reactor, else `None` (excluding the unlinked directories is enough then).
+    ///
+    /// jdtls imports an aggregator together with all of its modules, whatever its import
+    /// exclusions say, so a reactor keeping an unlinked module is left out; its other linked
+    /// modules are listed on their own. Such an aggregator (`pom` packaging) has no sources.
+    pub fn import_poms(&self, model: &MavenModel) -> Option<Vec<String>> {
+        let linked: Vec<&MavenProject> = model.projects.iter().filter(|p| !self.contains(&p.pom)).collect();
+        if !linked.iter().any(|p| p.modules.iter().any(|m| self.contains(m))) {
+            return None;
+        }
+        let by_pom: std::collections::HashMap<String, &MavenProject> =
+            model.projects.iter().map(|p| (normalized_pom(&p.pom), p)).collect();
+        // Whether `pom`'s module tree reaches an unlinked POM.
+        let reaches_unlinked = |pom: &str| {
+            let mut seen = std::collections::HashSet::new();
+            let mut pending = vec![normalized_pom(pom)];
+            while let Some(pom) = pending.pop() {
+                if !seen.insert(pom.clone()) {
+                    continue;
+                }
+                let Some(project) = by_pom.get(&pom) else { continue };
+                for module in &project.modules {
+                    if self.contains(module) {
+                        return true;
+                    }
+                    pending.push(normalized_pom(module));
+                }
+            }
+            false
+        };
+        Some(linked.into_iter().filter(|p| !reaches_unlinked(&p.pom)).map(|p| normalized_pom(&p.pom)).collect())
+    }
+
     pub fn filter(&self, model: &mut MavenModel) {
         model.projects.retain(|p| !self.contains(&p.pom));
         for project in &mut model.projects {
@@ -1524,6 +1604,52 @@ mod tests {
         assert!(model.projects.iter().any(|p| p.pom == "core/pom.xml" && p.aggregated));
     }
 
+    #[test]
+    fn modules_inherit_the_compiler_level_of_the_parent_plugin_configuration() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        let parent = |build: &str| {
+            format!(
+                r#"<project><groupId>demo</groupId><artifactId>parent</artifactId><version>1.0</version><packaging>pom</packaging>
+                  <modules><module>core</module><module>app</module></modules>
+                  <properties><jdk>17</jdk></properties>{build}</project>"#
+            )
+        };
+        let child = |name: &str, build: &str| {
+            format!(
+                r#"<project><parent><groupId>demo</groupId><artifactId>parent</artifactId><version>1.0</version></parent>
+                  <artifactId>{name}</artifactId>{build}</project>"#
+            )
+        };
+        let compiler = |level: &str| {
+            format!(
+                "<plugin><artifactId>maven-compiler-plugin</artifactId><configuration><source>{level}</source></configuration></plugin>"
+            )
+        };
+        let versions = |model: &MavenModel| -> Vec<(String, Option<u32>)> {
+            model.projects.iter().map(|p| (p.pom.clone(), p.java_version)).collect()
+        };
+        let app_build = format!("<build><plugins>{}</plugins></build>", compiler("21"));
+        write(root, "core/pom.xml", &child("core", ""));
+        write(root, "app/pom.xml", &child("app", &app_build));
+        for build in [
+            format!("<build><pluginManagement><plugins>{}</plugins></pluginManagement></build>", compiler("${jdk}")),
+            format!("<build><plugins>{}</plugins></build>", compiler("1.8")),
+        ] {
+            write(root, "pom.xml", &parent(&build));
+            let expected = if build.contains("1.8") { 8 } else { 17 };
+            assert_eq!(
+                versions(&load_with_repo(root, None)),
+                [
+                    ("pom.xml".to_owned(), Some(expected)),
+                    ("core/pom.xml".to_owned(), Some(expected)),
+                    ("app/pom.xml".to_owned(), Some(21)),
+                ],
+                "{build}"
+            );
+        }
+    }
+
     #[test]
     fn multi_module_parent_properties_and_managed_versions() {
         let tmp = tempfile::tempdir().unwrap();
@@ -1607,6 +1733,52 @@ mod tests {
         assert!(model.projects.iter().all(|p| p.command == if cfg!(windows) { "mvn.cmd" } else { "mvn" }));
     }
 
+    #[test]
+    fn chosen_profiles_bring_their_modules_and_dependencies() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        write(
+            root,
+            "pom.xml",
+            r#"<project><groupId>demo</groupId><artifactId>parent</artifactId><version>1.0</version><packaging>pom</packaging>
+              <modules><module>core</module></modules>
+              <profiles>
+                <profile><id>flink-1.17</id><activation><activeByDefault>true</activeByDefault></activation>
+                  <modules><module>flink-1.17</module></modules></profile>
+                <profile><id>flink-1.20</id><modules><module>flink-1.20</module></modules>
+                  <dependencies><dependency><groupId>org.apache.flink</groupId><artifactId>flink-core</artifactId><version>1.20.0</version></dependency></dependencies>
+                </profile>
+              </profiles>
+            </project>"#,
+        );
+        for m in ["core", "flink-1.17", "flink-1.20"] {
+            write(
+                root,
+                &format!("{m}/pom.xml"),
+                &format!(
+                    "<project><parent><groupId>demo</groupId><artifactId>parent</artifactId><version>1.0</version></parent><artifactId>{m}</artifactId></project>"
+                ),
+            );
+        }
+        let dirs = |m: &MavenModel| m.projects.iter().map(|p| p.dir.clone()).collect::<Vec<_>>();
+        let flink = |m: &MavenModel, dir: &str| {
+            m.projects.iter().find(|p| p.dir == dir).unwrap().dependencies.iter().any(|d| d.artifact_id == "flink-core")
+        };
+
+        let default = load_with(root, None, &[]);
+        assert_eq!(dirs(&default), ["", "core", "flink-1.17"]);
+        assert!(!flink(&default, "core"));
+
+        // Choosing another profile of the POM turns its activeByDefault one off (as `-P` does).
+        let chosen = load_with(root, None, &["flink-1.20".into()]);
+        assert_eq!(dirs(&chosen), ["", "core", "flink-1.20"]);
+        assert!(flink(&chosen, "core"), "a module inherits the chosen profile's dependencies");
+
+        let both = load_with(root, None, &["flink-1.20".into(), "flink-1.17".into()]);
+        assert_eq!(dirs(&both), ["", "core", "flink-1.17", "flink-1.20"]);
+        assert_eq!(dirs(&load_with(root, None, &["!flink-1.17".into()])), ["", "core"]);
+    }
+
     #[test]
     fn profiles_of_a_parent_pom_are_inherited() {
         let tmp = tempfile::tempdir().unwrap();
@@ -1935,4 +2107,51 @@ mod linkage_tests {
         UnlinkedProjects::from_model(&original, &MavenSettings::default()).filter(&mut restored);
         assert_eq!(restored, original);
     }
+
+    #[test]
+    fn language_server_imports_reactor_modules_individually_once_one_is_unlinked() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        // r ─┬─ x
+        //    ├─ y ─┬─ y/y1
+        //    │     └─ y/y2
+        //    └─ z          other/ is a separate root.
+        for (dir, modules) in [
+            ("r", "<modules><module>x</module><module>y</module><module>z</module></modules>"),
+            ("r/x", ""),
+            ("r/y", "<modules><module>y1</module><module>y2</module></modules>"),
+            ("r/y/y1", ""),
+            ("r/y/y2", ""),
+            ("r/z", ""),
+            ("other", ""),
+        ] {
+            std::fs::create_dir_all(root.join(dir)).unwrap();
+            std::fs::write(
+                root.join(dir).join("pom.xml"),
+                format!("<project><artifactId>{dir}</artifactId>{modules}</project>"),
+            )
+            .unwrap();
+        }
+        let model = load_with_repo(root, None);
+        let cases: [(&[&str], Option<&[&str]>); 5] = [
+            // Nothing unlinked, or whole roots: the import exclusions do it.
+            (&[], None),
+            (&["other/pom.xml"], None),
+            (&["r/pom.xml"], None),
+            // A module of a linked reactor: every other linked POM, minus the aggregators above it.
+            (&["r/y/y1/pom.xml"], Some(&["other/pom.xml", "r/x/pom.xml", "r/y/y2/pom.xml", "r/z/pom.xml"])),
+            (&["./r/y/pom.xml"], Some(&["other/pom.xml", "r/x/pom.xml", "r/z/pom.xml"])),
+        ];
+        for (unlinked, expected) in cases {
+            let settings = MavenSettings {
+                unlinked_projects: unlinked.iter().map(|s| s.to_string()).collect(),
+                ..Default::default()
+            };
+            let mut poms = UnlinkedProjects::from_model(&model, &settings).import_poms(&model);
+            if let Some(poms) = &mut poms {
+                poms.sort();
+            }
+            assert_eq!(poms, expected.map(|e| e.iter().map(|s| s.to_string()).collect::<Vec<_>>()), "{unlinked:?}");
+        }
+    }
 }

crates/ide-build/src/sync.rs

@@ -4,14 +4,16 @@
 //! per project (`maven.json`, `gradle.json` in the cache directory) and merged
 //! into the static model by [`crate::load`]; a changed build file marks them stale.
 
-use crate::gradle::{self, GradleModel, GradleTask};
+use crate::gradle::{self, GradleModel, GradleTask, ReportedProject, parse_reported_projects};
 use crate::maven::{self, MavenDependency, MavenModel, MavenPlugin};
 use crate::process::{self, Output};
 use ide_core::{CancellationToken, IdeError, IdeResult};
 use serde::{Deserialize, Serialize, de::DeserializeOwned};
 use specta::Type;
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, HashMap};
 use std::path::{Path, PathBuf};
+use std::sync::{Arc, LazyLock, Mutex};
+use std::time::SystemTime;
 
 #[derive(Clone, Debug, Serialize, Deserialize, Type)]
 #[serde(rename_all = "camelCase")]
@@ -68,8 +70,14 @@ struct GradleCache {
     at_ms: f64,
     error: Option<String>,
     tasks: Vec<(String, GradleTask)>,
+    /// The projects as Gradle evaluated them; empty in caches from before they were read.
+    #[serde(default)]
+    projects: Vec<ReportedProject>,
 }
 
+/// Init script printing every project, its source sets and Java version once configured.
+const MODEL_INIT_SCRIPT: &str = include_str!("gradle-model.gradle");
+
 const MAVEN_CACHE: &str = "maven.json";
 const MAVEN_CACHE_VERSION: u32 = 1;
 
@@ -122,6 +130,20 @@ fn write_cache<T: Serialize>(dir: &Path, name: &str, value: &T) -> IdeResult<()>
 
 /// FNV-1a over the paths and contents of `files` (missing files count as empty).
 fn hash_files(files: &[PathBuf]) -> String {
+    hash_contents(files, |f| std::fs::read(f).unwrap_or_default())
+}
+
+/// Like IDEA's auto-import CRC: editing a comment or reformatting a build script
+/// does not make the last sync stale.
+fn hash_gradle_files(files: &[PathBuf]) -> String {
+    hash_contents(files, |f| {
+        let text = std::fs::read_to_string(f).unwrap_or_default();
+        let script = f.extension().is_some_and(|e| e == "gradle" || e == "kts");
+        if script { gradle::script_fingerprint(&text) } else { text }.into_bytes()
+    })
+}
+
+fn hash_contents(files: &[PathBuf], read: impl Fn(&Path) -> Vec<u8>) -> String {
     let mut h: u64 = 0xcbf29ce484222325;
     let mut feed = |bytes: &[u8]| {
         for b in bytes {
@@ -132,7 +154,7 @@ fn hash_files(files: &[PathBuf]) -> String {
     for f in files {
         feed(f.to_string_lossy().as_bytes());
         feed(&[0]);
-        feed(&std::fs::read(f).unwrap_or_default());
+        feed(&read(f));
         feed(&[0]);
     }
     format!("{h:016x}")
@@ -168,9 +190,33 @@ pub fn apply_maven_cache(root: &Path, cache_dir: &Path, model: &mut MavenModel)
     }
 }
 
+/// The projects of the last successful Gradle sync.
+/// Parsed once per change of the cache file (modification time and size): content and source
+/// roots are read on hot paths (every references search, Find in Files, repository scans).
+pub fn reported_gradle_projects(cache_dir: &Path) -> Arc<Vec<ReportedProject>> {
+    type Memo = HashMap<PathBuf, (Option<SystemTime>, u64, Arc<Vec<ReportedProject>>)>;
+    static MEMO: LazyLock<Mutex<Memo>> = LazyLock::new(Default::default);
+    let path = cache_dir.join(GRADLE_CACHE);
+    let Ok(meta) = std::fs::metadata(&path) else {
+        MEMO.lock().unwrap_or_else(|e| e.into_inner()).remove(&path);
+        return Arc::default();
+    };
+    let stamp = (meta.modified().ok(), meta.len());
+    let mut memo = MEMO.lock().unwrap_or_else(|e| e.into_inner());
+    if let Some((modified, len, projects)) = memo.get(&path)
+        && (*modified, *len) == stamp
+    {
+        return projects.clone();
+    }
+    let projects = Arc::new(read_cache::<GradleCache>(cache_dir, GRADLE_CACHE).map(|c| c.projects).unwrap_or_default());
+    memo.insert(path, (stamp.0, stamp.1, projects.clone()));
+    projects
+}
+
 /// Merges the cached task list into `model`.
 pub fn apply_gradle_cache(root: &Path, cache_dir: &Path, model: &mut GradleModel) {
     let Some(cache) = read_cache::<GradleCache>(cache_dir, GRADLE_CACHE) else { return };
+    gradle::merge_reported_projects(root, model, &cache.projects);
     if !cache.tasks.is_empty() {
         for p in &mut model.projects {
             let tasks: Vec<GradleTask> =
@@ -180,9 +226,11 @@ pub fn apply_gradle_cache(root: &Path, cache_dir: &Path, model: &mut GradleModel
             }
         }
     }
+    // A successful sync from before projects were cached has not seen computed includes.
+    let without_projects = cache.error.is_none() && cache.projects.is_empty();
     model.synced_at = Some(cache.at_ms);
     model.sync_error = cache.error;
-    model.stale = cache.hash != hash_files(&gradle::build_files(root, model));
+    model.stale = without_projects || cache.hash != hash_gradle_files(&gradle::build_files(root, model));
 }
 
 // ---------------------------------------------------------------- processes
@@ -235,7 +283,7 @@ pub fn sync_maven(
     cancel: &CancellationToken,
     progress: &dyn Fn(SyncProgress),
 ) -> IdeResult<()> {
-    let mut model = maven::load(root);
+    let mut model = maven::load_with_profiles(root, &options.profiles);
     maven::UnlinkedProjects::from_model(&model, &options.maven_settings).filter(&mut model);
     std::fs::create_dir_all(cache_dir)?;
     let mut cache = MavenCache {
@@ -267,7 +315,10 @@ pub fn sync_maven(
     for (n, top) in model.projects.iter().filter(|p| !p.aggregated).enumerate() {
         let effective = cache_dir.join(format!("effective-pom-{n}.xml"));
         let _ = std::fs::remove_file(&effective);
-        let mut args: Vec<String> = vec!["-B".into(), "-fae".into(), "-Dstyle.color=never".into()];
+        // `-T1` keeps mvnd serial: its default parallel build interleaves the
+        // `dependency:tree` output of concurrent modules, which the sync parses
+        // as one stream. mvn is serial anyway, so this only pins the daemon.
+        let mut args: Vec<String> = vec!["-B".into(), "-fae".into(), "-Dstyle.color=never".into(), "-T1".into()];
         args.extend(options.maven_options.iter().cloned());
         if options.offline {
             args.push("-o".into());
@@ -322,8 +373,18 @@ pub fn sync_gradle(
     cancel: &CancellationToken,
     progress: &dyn Fn(SyncProgress),
 ) -> IdeResult<()> {
-    let model = gradle::load(root).ok_or_else(|| IdeError::not_found("no Gradle build in this project"))?;
-    let mut args: Vec<String> = vec!["--console=plain".into(), "-q".into(), "tasks".into(), "--all".into()];
+    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 init_script = cache_dir.join("openidea-model.gradle");
+    std::fs::write(&init_script, MODEL_INIT_SCRIPT)?;
+    let mut args: Vec<String> = vec![
+        "--console=plain".into(),
+        "-q".into(),
+        "--init-script".into(),
+        init_script.to_string_lossy().into_owned(),
+        "tasks".into(),
+        "--all".into(),
+    ];
     if options.offline {
         args.push("--offline".into());
     }
@@ -336,11 +397,15 @@ pub fn sync_gradle(
         cancel,
         |_| {},
     )?;
+    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);
     let cache = GradleCache {
-        hash: hash_files(&gradle::build_files(root, &model)),
+        hash: hash_gradle_files(&gradle::build_files(root, &model)),
         at_ms: now_ms(),
         error: (!out.success).then(|| error_summary(&out.text)),
         tasks: if out.success { gradle::parse_tasks(&out.text) } else { Vec::new() },
+        projects,
     };
     write_cache(cache_dir, GRADLE_CACHE, &cache)
 }
@@ -456,6 +521,93 @@ mod tests {
         assert!(model.projects[0].dependencies.iter().all(|d| d.artifact_id != "cached"));
     }
 
+    #[test]
+    fn gradle_reported_projects_replace_static_ones() {
+        let tmp = tempfile::tempdir().unwrap();
+        let ws = dunce::canonicalize(tmp.path()).unwrap();
+        let root = ws.join("app");
+        let billing = ws.join("billing");
+        std::fs::create_dir_all(root.join("shared")).unwrap();
+        std::fs::create_dir_all(billing.join("modules/core")).unwrap();
+        // Computed includes: nothing a static reading can see.
+        std::fs::write(root.join("settings.gradle"), "rootProject.name = 'Shop'\n['billing'].each { includeFlat it }")
+            .unwrap();
+        std::fs::write(billing.join("modules/core/build.gradle"), "apply plugin: 'java'").unwrap();
+        // Built with serde: a Windows path holds backslashes, which raw JSON text would leave unescaped.
+        let line = |p: ReportedProject| format!("@openidea-model\t{}\n", serde_json::to_string(&p).unwrap());
+        let (r, b) = (root.display().to_string(), billing.display().to_string());
+        let core_src = |p: &str| format!("{b}/modules/core/src/{p}");
+        let set = |name: &str, test: bool, src: &[&str], res: &[&str]| gradle::ReportedSourceSet {
+            name: name.into(),
+            test,
+            src: src.iter().map(|p| core_src(p)).collect(),
+            res: res.iter().map(|p| core_src(p)).collect(),
+        };
+        // A settings script's own println comes first; task listing lines follow.
+        let out = format!(
+            "configuring billing\n{}{}{}@openidea-model\t{{broken\n\nOther tasks\n-----------\nbilling:core:jar\n",
+            line(ReportedProject { path: ":".into(), dir: r.clone(), ..ReportedProject::default() }),
+            line(ReportedProject {
+                path: ":billing".into(),
+                dir: b.clone(),
+                java: Some(17),
+                ..ReportedProject::default()
+            }),
+            line(ReportedProject {
+                path: ":billing:core".into(),
+                dir: format!("{b}/modules/core"),
+                java: Some(21),
+                source_sets: vec![
+                    set("main", false, &["main/java"], &["main/resources"]),
+                    set("test", true, &["main/java", "test/java"], &[]),
+                ],
+                ..ReportedProject::default()
+            }),
+        );
+        let projects = parse_reported_projects(&out);
+        assert_eq!(projects.len(), 3, "the malformed line is skipped");
+        let src = |p: &str| PathBuf::from(core_src(p));
+        assert_eq!(
+            gradle::reported_source_roots(&projects),
+            [
+                (src("main/java"), gradle::ReportedRoot::Source),
+                (src("main/resources"), gradle::ReportedRoot::Resources),
+                (src("test/java"), gradle::ReportedRoot::Test),
+            ]
+        );
+        let mut model = gradle::load(&root).unwrap();
+        assert_eq!(model.projects.len(), 1);
+        gradle::merge_reported_projects(&root, &mut model, &projects);
+        let paths: Vec<_> = model.projects.iter().map(|p| (p.path.as_str(), p.name.as_str())).collect();
+        assert_eq!(paths, [(":", "Shop"), (":billing", "billing"), (":billing:core", "core")]);
+        assert_eq!(model.projects[0].dir, "");
+        assert!(root.join(model.projects[2].build_file.as_ref().unwrap()).is_file());
+        assert_eq!(
+            gradle::external_roots(&root, model.projects.iter().map(|p| p.dir.as_str())),
+            std::slice::from_ref(&billing)
+        );
+        assert_eq!(model.java_version, Some(21), "the newest version any module needs");
+        assert_eq!(
+            gradle::parse_tasks(&out),
+            [(":billing:core".into(), GradleTask { name: "jar".into(), group: "other".into(), description: None })]
+        );
+
+        // The cached projects are parsed once per change of the cache file.
+        let cache_dir = ws.join("cache");
+        let write = |projects: &[ReportedProject]| {
+            let cache = GradleCache { projects: projects.to_vec(), ..GradleCache::default() };
+            write_cache(&cache_dir, GRADLE_CACHE, &cache).unwrap();
+        };
+        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]);
+        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();
+        assert!(reported_gradle_projects(&cache_dir).is_empty());
+    }
+
     #[test]
     fn gradle_cache_replaces_tasks_per_project() {
         let tmp = tempfile::tempdir().unwrap();
@@ -466,16 +618,39 @@ mod tests {
         std::fs::write(root.join("app/build.gradle"), "apply plugin: 'java'").unwrap();
         let mut model = gradle::load(&root).unwrap();
         let cache = GradleCache {
-            hash: hash_files(&gradle::build_files(&root, &model)),
+            hash: hash_gradle_files(&gradle::build_files(&root, &model)),
             at_ms: 1.0,
             error: None,
             tasks: vec![(":app".into(), GradleTask { name: "hello".into(), group: "demo".into(), description: None })],
+            projects: [":", ":app"]
+                .iter()
+                .zip([root.clone(), root.join("app")])
+                .map(|(path, dir)| ReportedProject {
+                    path: (*path).into(),
+                    dir: dir.to_string_lossy().into_owned(),
+                    ..Default::default()
+                })
+                .collect(),
         };
         write_cache(&cache_dir, GRADLE_CACHE, &cache).unwrap();
         apply_gradle_cache(&root, &cache_dir, &mut model);
         assert_eq!(model.projects[1].tasks.len(), 1);
         assert!(model.projects[0].tasks.iter().any(|t| t.name == "wrapper"), "root keeps its defaults");
         assert!(!model.stale);
+
+        let stale_after = |script: &str| {
+            std::fs::write(root.join("app/build.gradle"), script).unwrap();
+            let mut m = gradle::load(&root).unwrap();
+            apply_gradle_cache(&root, &cache_dir, &mut m);
+            m.stale
+        };
+        assert!(!stale_after("// a note\napply   plugin: 'java'\n"), "comments and spacing don't count");
+        assert!(stale_after("apply plugin: 'groovy'"));
+        std::fs::write(root.join("app/build.gradle"), "apply plugin: 'java'").unwrap();
+        std::fs::write(root.join("gradle.properties"), "org.gradle.jvmargs=-Xmx2g").unwrap();
+        let mut m = gradle::load(&root).unwrap();
+        apply_gradle_cache(&root, &cache_dir, &mut m);
+        assert!(m.stale, "gradle.properties is watched");
     }
 
     #[test]
@@ -508,4 +683,25 @@ mod tests {
         assert_eq!(error_summary(text), "Failed to execute goal");
         assert_eq!(error_summary("one\nlast line\n\n"), "last line");
     }
+
+    #[cfg(unix)]
+    #[test]
+    fn maven_sync_runs_the_daemon_command_serially() {
+        use std::os::unix::fs::PermissionsExt;
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path().join("p");
+        std::fs::create_dir_all(&root).unwrap();
+        std::fs::write(root.join("pom.xml"), "<project><groupId>g</groupId><artifactId>a</artifactId></project>")
+            .unwrap();
+        let launcher = tmp.path().join("fake-mvnd");
+        std::fs::write(&launcher, "#!/bin/sh\nprintf '%s\\n' \"$@\" > mvnd-args\n").unwrap();
+        std::fs::set_permissions(&launcher, std::fs::Permissions::from_mode(0o755)).unwrap();
+        let options =
+            SyncOptions { maven_command: Some(launcher.to_string_lossy().into_owned()), ..Default::default() };
+        sync_maven(&root, &tmp.path().join("cache"), &options, &CancellationToken::new(), &|_| {}).unwrap();
+        let args = std::fs::read_to_string(root.join("mvnd-args")).unwrap();
+        // `-T1` pins the daemon serial so the dependency trees stay parseable.
+        assert!(args.contains("-T1"), "args: {args}");
+        assert!(args.contains("help:effective-pom"), "args: {args}");
+    }
 }

crates/ide-core/Cargo.toml

@@ -22,4 +22,4 @@ tempfile.workspace = true
 libc = "0.2"
 
 [target.'cfg(windows)'.dependencies]
-windows-sys = { version = "0.61", features = ["Win32_Globalization", "Win32_Security", "Win32_System_Registry", "Win32_Foundation"] }
+windows-sys = { version = "0.61", features = ["Win32_Globalization", "Win32_Security", "Win32_System_Registry", "Win32_Foundation", "Win32_System_Diagnostics_ToolHelp", "Win32_System_Threading"] }

crates/ide-core/src/ignored.rs

@@ -2,6 +2,18 @@
 //! treats as nonexistent — hidden from the project view and navigation, never
 //! indexed or searched, never offered as unversioned changes.
 
+use std::path::Path;
+
+/// Whether `dir` lies in a Git (or jj) working tree: it or an ancestor holds `.git` / `.jj`.
+///
+/// Walkers pass it to `ignore::WalkBuilder::require_git`: inside a repository, `.gitignore`
+/// rules then stop at a nested repository's root as in git, so an outer repository's
+/// `.gitignore` does not hide a project that is its own repository. A folder outside any
+/// repository still honours its `.gitignore`.
+pub fn inside_git_repo(dir: &Path) -> bool {
+    dir.ancestors().any(|d| d.join(".git").exists() || d.join(".jj").exists())
+}
+
 /// IDEA's default list, plus `.jj` and the Windows shell files.
 pub const DEFAULT_IGNORED_NAMES: &[&str] = &[
     "*.pyc",
@@ -103,4 +115,15 @@ mod tests {
         assert!(m.is_ignored_path("pkg/__pycache__/mod.cpython-312.pyc"));
         assert!(!m.is_ignored_path("src/main.rs"));
     }
+
+    #[test]
+    fn finds_the_repository_at_or_above_a_directory() {
+        let dir = tempfile::tempdir().unwrap();
+        let sub = dir.path().join("a/b");
+        std::fs::create_dir_all(&sub).unwrap();
+        assert!(!inside_git_repo(&sub));
+        std::fs::create_dir(dir.path().join("a/.git")).unwrap();
+        assert!(inside_git_repo(&sub));
+        assert!(inside_git_repo(&dir.path().join("a")));
+    }
 }

crates/ide-core/src/output_encoding.rs

@@ -13,7 +13,10 @@
 //!   they fork get them too (`spring-boot:run`, Surefire, `bootRun`, test workers).
 //!   Each JVM then reports "Picked up JAVA_TOOL_OPTIONS: …" on stderr (which a build tool
 //!   may copy to its stdout); that line is hidden again ([`NoticeFilter`]). `file.encoding` is left alone there: it would change
-//!   how a build reads sources that declare no encoding.
+//!   how a build reads sources that declare no encoding. The application JVMs a build
+//!   forks get `file.encoding=UTF-8` for a UTF-8 console instead, through the build's own
+//!   options: `-Dspring-boot.run.jvmArguments` for Maven `spring-boot:run`, an init script
+//!   ([`GRADLE_FILE_ENCODING_SCRIPT`]) for Gradle `JavaExec` tasks (`bootRun`, `run`).
 //! - Python: `PYTHONIOENCODING`.
 
 use std::collections::BTreeMap;
@@ -75,16 +78,34 @@ fn encoding_for_code_page(cp: u32) -> Option<&'static encoding_rs::Encoding> {
 const STD_PROPERTIES: &[&str] = &["stdout.encoding", "stderr.encoding", "sun.stdout.encoding", "sun.stderr.encoding"];
 const FILE_ENCODING: &str = "file.encoding";
 const TOOL_OPTIONS: &str = "JAVA_TOOL_OPTIONS";
+const SPRING_BOOT_JVM_ARGS: &str = "-Dspring-boot.run.jvmArguments=";
 
 /// Build tools and launcher scripts that run on (and may fork) JVMs.
-const JVM_TOOLS: &[&str] =
-    &["mvn", "mvnw", "mvnd", "gradle", "gradlew", "sbt", "ant", "kotlin", "kotlinc", "groovy", "scala", "jbang"];
+const JVM_TOOLS: &[&str] = &["sbt", "ant", "kotlin", "kotlinc", "groovy", "scala", "jbang"];
+const MAVEN: &[&str] = &["mvn", "mvnw", "mvnd"];
+const GRADLE: &[&str] = &["gradle", "gradlew"];
+
+/// Gradle init script giving the `JavaExec` tasks (`bootRun`, `run`, custom ones) a UTF-8
+/// default charset before the build configures them, so the build can override it.
+/// Gradle's own JVM and the compiler's source encoding are untouched.
+pub const GRADLE_FILE_ENCODING_SCRIPT: &str = "\
+// Written by OpenIDEA: a UTF-8 default charset for applications run by Gradle, as the Run console decodes UTF-8.
+allprojects {
+    tasks.withType(JavaExec).configureEach {
+        defaultCharacterEncoding = 'UTF-8'
+    }
+}
+";
 
 /// What a launch needs: `-D` options to put first on a `java` command line,
 /// environment variables to set, and the notice line its JVMs print because of them.
 #[derive(Debug, Default, PartialEq, Eq)]
 pub struct EncodingFix {
     pub java_args: Vec<String>,
+    /// The build tool's arguments, rewritten to pass options to the JVM it forks.
+    pub args: Option<Vec<String>>,
+    /// Gradle: pass [`GRADLE_FILE_ENCODING_SCRIPT`] with `--init-script`.
+    pub gradle_init_script: bool,
     pub env: Vec<(String, String)>,
     /// "Picked up JAVA_TOOL_OPTIONS: …" for a variable set here alone, to drop from the output.
     pub notice: Option<String>,
@@ -116,6 +137,8 @@ fn options(properties: &[&str], encoding: &str) -> Vec<String> {
 #[derive(Clone, Copy, PartialEq, Eq)]
 enum Kind {
     Java,
+    Maven,
+    Gradle,
     JvmTool,
     Python,
     Other,
@@ -125,6 +148,10 @@ fn kind(program: &str) -> Kind {
     let name = program_name(program);
     if name == "java" || name == "javaw" {
         Kind::Java
+    } else if MAVEN.contains(&name.as_str()) {
+        Kind::Maven
+    } else if GRADLE.contains(&name.as_str()) {
+        Kind::Gradle
     } else if JVM_TOOLS.contains(&name.as_str()) {
         Kind::JvmTool
     } else if is_python(&name) {
@@ -193,7 +220,17 @@ fn fix_kind(
                 out.java_args.push(format!("-D{FILE_ENCODING}=UTF-8"));
             }
         }
-        (Kind::Java | Kind::JvmTool, _) => {
+        (Kind::Java | Kind::Maven | Kind::Gradle | Kind::JvmTool, _) => {
+            if let Some(args) = args
+                && is_utf8(encoding)
+                && !sets(&tool_options, &[FILE_ENCODING])
+            {
+                match kind {
+                    Kind::Maven => out.args = spring_boot_file_encoding(args),
+                    Kind::Gradle => out.gradle_init_script = true,
+                    _ => {}
+                }
+            }
             if !sets(&tool_options, STD_PROPERTIES) {
                 let added = options(STD_PROPERTIES, encoding).join(" ");
                 let value = match tool_options.trim() {
@@ -214,6 +251,26 @@ fn fix_kind(
     out
 }
 
+fn spring_boot_file_encoding(args: &[String]) -> Option<Vec<String>> {
+    if !args.iter().any(|a| a == "spring-boot:run" || (a.contains(":spring-boot-maven-plugin:") && a.ends_with(":run")))
+    {
+        return None;
+    }
+    let option = format!("-D{FILE_ENCODING}=UTF-8");
+    let mut out = args.to_vec();
+    match out.iter_mut().rfind(|a| a.starts_with(SPRING_BOOT_JVM_ARGS)) {
+        Some(own) if sets(own, &[FILE_ENCODING]) => return None,
+        Some(own) => {
+            if own.len() > SPRING_BOOT_JVM_ARGS.len() {
+                own.push(' ');
+            }
+            own.push_str(&option);
+        }
+        None => out.push(format!("{SPRING_BOOT_JVM_ARGS}{option}")),
+    }
+    Some(out)
+}
+
 /// `vmArgs` of a launch by java-debug, which decodes the JVM's output as `encoding`
 /// (its launch attribute, UTF-8 when unset). java-debug sets `file.encoding` only
 /// when that attribute is nonblank; use the same defaults and user overrides as [`fix`].
@@ -435,6 +492,64 @@ mod tests {
         assert_eq!(run("python3", &[], &[], "GBK", false).env, [("PYTHONIOENCODING".to_owned(), "GBK".to_owned())]);
     }
 
+    #[test]
+    fn spring_boot_run_forks_get_a_utf8_default_charset() {
+        let boot = |args: &[&str], env: &[(&str, &str)]| run("mvn.cmd", args, env, "UTF-8", true).args;
+        let utf8 = "-Dspring-boot.run.jvmArguments=-Dfile.encoding=UTF-8";
+        assert_eq!(boot(&["spring-boot:run"], &[]).unwrap(), ["spring-boot:run", utf8]);
+        let plugin = "org.springframework.boot:spring-boot-maven-plugin:3.2.0:run";
+        assert_eq!(boot(&["-pl", "app", plugin], &[]).unwrap(), ["-pl", "app", plugin, utf8]);
+        // The user's VM options are kept; their own `file.encoding` wins.
+        assert_eq!(
+            boot(&["spring-boot:run", "-Dspring-boot.run.jvmArguments=-Xmx1g \"-Da=b c\""], &[]).unwrap(),
+            ["spring-boot:run", "-Dspring-boot.run.jvmArguments=-Xmx1g \"-Da=b c\" -Dfile.encoding=UTF-8"]
+        );
+        assert_eq!(boot(&["spring-boot:run", "-Dspring-boot.run.jvmArguments="], &[]).unwrap()[1], utf8);
+        assert!(boot(&["spring-boot:run", "-Dspring-boot.run.jvmArguments=-Dfile.encoding=GBK"], &[]).is_none());
+        assert!(boot(&["spring-boot:run"], &[(TOOL_OPTIONS, "-Dfile.encoding=GBK")]).is_none());
+        // Other goals and tools, other consoles, and other platforms are left alone.
+        assert!(boot(&["package"], &[]).is_none());
+        assert!(run("mvn", &["spring-boot:run"], &[], "GBK", true).args.is_none());
+        assert!(run("mvn", &["spring-boot:run"], &[], "UTF-8", false).args.is_none());
+    }
+
+    #[test]
+    fn forked_application_jvms_get_a_utf8_default_charset() {
+        // Reported: a Spring Boot app run by the build on Chinese Windows (JDK 8–17, GBK default).
+        for (tool, args) in [
+            ("C:\\p\\gradlew.bat", &["bootRun"][..]),
+            ("gradle", &[":app:run"]),
+            ("mvnw.cmd", &["spring-boot:run"]),
+            ("mvnd", &["org.springframework.boot:spring-boot-maven-plugin:2.7.18:run"]),
+        ] {
+            let f = run(tool, args, &[], "UTF-8", true);
+            let gradle = tool.contains("gradle");
+            assert_eq!(f.gradle_init_script, gradle, "{tool}");
+            assert_eq!(f.args.is_some(), !gradle, "{tool}");
+            // The build tool's own JVM keeps its default charset.
+            assert!(!tool_env(&f).unwrap().contains("file.encoding"), "{tool}");
+            // The user's choice, a GBK console and other platforms are left alone.
+            let own = run(tool, args, &[(TOOL_OPTIONS, "-Dfile.encoding=GBK")], "UTF-8", true);
+            assert!(!own.gradle_init_script && own.args.is_none(), "{tool}");
+            let gbk = run(tool, args, &[], "GBK", true);
+            assert!(!gbk.gradle_init_script && gbk.args.is_none(), "{tool}");
+            assert_eq!(run(tool, args, &[], "UTF-8", false), EncodingFix::default(), "{tool}");
+        }
+        // Shell command lines can't take arguments; other JVM tools fork no application.
+        assert!(!fix_command_line("gradlew bootRun", &BTreeMap::new(), |_| None, "UTF-8", true).gradle_init_script);
+        let sbt = run("sbt", &["run"], &[], "UTF-8", true);
+        assert!(!sbt.gradle_init_script && sbt.args.is_none());
+    }
+
+    #[test]
+    fn gradle_script_respects_the_builds_own_file_encoding() {
+        let s = GRADLE_FILE_ENCODING_SCRIPT;
+        assert!(s.contains("tasks.withType(JavaExec).configureEach"), "{s}");
+        assert!(s.contains("defaultCharacterEncoding = 'UTF-8'"), "{s}");
+        assert!(!s.contains("doFirst"), "the build must be able to override the default: {s}");
+        assert!(!s.contains("withType(Test)") && !s.contains("JavaCompile"), "{s}");
+    }
+
     #[test]
     fn shell_command_lines_get_variables_from_their_first_word() {
         let line = |l: &str| fix_command_line(l, &BTreeMap::new(), |_| None, "UTF-8", true);

crates/ide-core/src/process.rs

@@ -43,16 +43,35 @@ pub fn own_group(cmd: &mut Command) -> &mut Command {
 /// Kills the child and everything it started, then reaps it.
 ///
 /// - Unix: `SIGKILL` to its process group, so spawn it with [`own_group`].
-/// - Windows: `taskkill /T /F`, which walks the tree from the child's process id.
+/// - Windows: `taskkill /T /F`, which walks the tree from the child's process id, then a
+///   wait for what the child started to be gone.
 pub fn kill_tree(child: &mut Child) {
     #[cfg(unix)]
     signal_group(child, libc::SIGKILL);
     #[cfg(windows)]
-    taskkill_tree(child);
+    taskkill_tree_of(child.id());
     let _ = child.kill();
     let _ = child.wait();
 }
 
+/// [`kill_tree`] for a child known by its process id (a `tokio` child): `SIGKILL` to its
+/// process group (spawn it with [`own_group`]) or `taskkill /T /F` and a wait for what the
+/// child started to be gone. Call it before the child is reaped, so the id still names it.
+/// The child itself is left to its owner to kill and reap.
+pub fn kill_tree_of(pid: u32) {
+    #[cfg(unix)]
+    if let Ok(pid) = libc::pid_t::try_from(pid) {
+        // SAFETY: plain syscall; see `signal_group`.
+        unsafe {
+            libc::kill(-pid, libc::SIGKILL);
+        }
+    }
+    #[cfg(windows)]
+    taskkill_tree_of(pid);
+    #[cfg(not(any(unix, windows)))]
+    let _ = pid;
+}
+
 /// [`kill_tree`] that first asks the group to exit: `SIGTERM`, then `grace`, then `SIGKILL`.
 /// Git removes its `index.lock` on `SIGTERM`, where `SIGKILL` leaves it behind and the next
 /// git command fails. Windows has no such signal to send from outside the child's console,
@@ -81,15 +100,107 @@ fn signal_group(child: &Child, signal: libc::c_int) {
     }
 }
 
+/// How long killing a tree waits for the processes the child started to be gone.
 #[cfg(windows)]
-fn taskkill_tree(child: &Child) {
+const TREE_EXIT_WAIT: Duration = Duration::from_secs(5);
+
+/// `taskkill /T /F` from `pid`, then waits (up to [`TREE_EXIT_WAIT`]) until what the child
+/// started is gone: termination is asynchronous, and until a process is gone the files it
+/// holds open can't be opened or deleted. The child itself is left to its owner to reap.
+#[cfg(windows)]
+fn taskkill_tree_of(pid: u32) {
+    let started = windows_tree::descendants(pid);
     let mut taskkill = Command::new("taskkill");
     prepare(&mut taskkill)
-        .args(["/T", "/F", "/PID", &child.id().to_string()])
+        .args(["/T", "/F", "/PID", &pid.to_string()])
         .stdin(Stdio::null())
         .stdout(Stdio::null())
         .stderr(Stdio::null());
     let _ = taskkill.status();
+    windows_tree::wait_all(&started, TREE_EXIT_WAIT);
+}
+
+#[cfg(windows)]
+mod windows_tree {
+    use std::collections::HashSet;
+    use std::os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle};
+    use std::time::{Duration, Instant};
+    use windows_sys::Win32::Foundation::{FILETIME, INVALID_HANDLE_VALUE};
+    use windows_sys::Win32::System::Diagnostics::ToolHelp::{
+        CreateToolhelp32Snapshot, PROCESSENTRY32W, Process32FirstW, Process32NextW, TH32CS_SNAPPROCESS,
+    };
+    use windows_sys::Win32::System::Threading::{
+        GetProcessTimes, OpenProcess, PROCESS_QUERY_LIMITED_INFORMATION, PROCESS_SYNCHRONIZE, WaitForSingleObject,
+    };
+
+    /// Every process `root` started, directly or not, opened so it can be waited for. A
+    /// parent's id is reused once it is gone, so a process counts only if it started after
+    /// its parent.
+    pub(super) fn descendants(root: u32) -> Vec<OwnedHandle> {
+        let Some(root_started) = open(root).as_ref().and_then(started) else { return Vec::new() };
+        let processes = processes();
+        let mut seen = HashSet::from([root]);
+        let mut parents = vec![(root, root_started)];
+        let mut found = Vec::new();
+        while let Some((parent, parent_started)) = parents.pop() {
+            for &(pid, ppid) in &processes {
+                if ppid != parent || !seen.insert(pid) {
+                    continue;
+                }
+                let Some(handle) = open(pid) else { continue };
+                if let Some(at) = started(&handle).filter(|&at| at >= parent_started) {
+                    parents.push((pid, at));
+                    found.push(handle);
+                }
+            }
+        }
+        found
+    }
+
+    pub(super) fn wait_all(processes: &[OwnedHandle], within: Duration) {
+        let until = Instant::now() + within;
+        for process in processes {
+            let left = until.saturating_duration_since(Instant::now());
+            // SAFETY: a live process handle opened with SYNCHRONIZE access.
+            unsafe { WaitForSingleObject(process.as_raw_handle(), left.as_millis().min(u32::MAX as u128 - 1) as u32) };
+        }
+    }
+
+    /// (process id, parent process id) of every running process.
+    fn processes() -> Vec<(u32, u32)> {
+        let mut out = Vec::new();
+        // SAFETY: a snapshot handle owned here and an entry sized as the API requires.
+        unsafe {
+            let snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
+            if snapshot.is_null() || snapshot == INVALID_HANDLE_VALUE {
+                return out;
+            }
+            let snapshot = OwnedHandle::from_raw_handle(snapshot);
+            let mut entry = PROCESSENTRY32W { dwSize: size_of::<PROCESSENTRY32W>() as u32, ..Default::default() };
+            let mut more = Process32FirstW(snapshot.as_raw_handle(), &mut entry);
+            while more != 0 {
+                out.push((entry.th32ProcessID, entry.th32ParentProcessID));
+                more = Process32NextW(snapshot.as_raw_handle(), &mut entry);
+            }
+        }
+        out
+    }
+
+    fn open(pid: u32) -> Option<OwnedHandle> {
+        // SAFETY: plain call; a non-null result is a process handle owned by the caller.
+        let handle = unsafe { OpenProcess(PROCESS_SYNCHRONIZE | PROCESS_QUERY_LIMITED_INFORMATION, 0, pid) };
+        // SAFETY: as above.
+        (!handle.is_null()).then(|| unsafe { OwnedHandle::from_raw_handle(handle) })
+    }
+
+    /// When the process started, in 100 ns ticks since 1601.
+    fn started(process: &OwnedHandle) -> Option<u64> {
+        let (mut created, mut exited, mut kernel, mut user) =
+            (FILETIME::default(), FILETIME::default(), FILETIME::default(), FILETIME::default());
+        // SAFETY: a live process handle opened with query access; four out-parameters.
+        let ok = unsafe { GetProcessTimes(process.as_raw_handle(), &mut created, &mut exited, &mut kernel, &mut user) };
+        (ok != 0).then(|| (u64::from(created.dwHighDateTime) << 32) | u64::from(created.dwLowDateTime))
+    }
 }
 
 /// Gives `cmd` the host's environment back when the IDE runs from an AppImage. `AppRun` and
@@ -98,12 +209,14 @@ fn taskkill_tree(child: &Child) {
 /// inherits them loads the image's (older) libraries and plugins next to its own, e.g.
 /// `curl: symbol lookup error ... nghttp2_...`. The IDE process keeps its environment
 /// (WebKit and GTK still need it). Then applies the [`set_env_overlay`] variables and
-/// those of a manual HTTP proxy ([`crate::proxy_settings::ProxySettings::child_env`]).
-/// Variables the call site has already set are kept. A no-op outside an AppImage
-/// without an overlay.
+/// those of a manual HTTP proxy ([`crate::proxy_settings::ProxySettings::child_env`]),
+/// and the login shell's variables this process lacks ([`shell_env`]: an app started from
+/// Finder/Dock doesn't have what rc files export, such as `GOPATH`, `JAVA_HOME` or
+/// `MAVEN_OPTS`). Variables the call site has already set are kept.
 pub fn host_env(cmd: &mut Command) -> &mut Command {
     let fixes = child_env_changes();
-    if fixes.is_empty() {
+    let shell: Vec<_> = shell_env().collect();
+    if fixes.is_empty() && shell.is_empty() {
         return cmd;
     }
     let explicit: Vec<OsString> = cmd.get_envs().map(|(k, _)| k.to_owned()).collect();
@@ -113,6 +226,9 @@ pub fn host_env(cmd: &mut Command) -> &mut Command {
             None => cmd.env_remove(key),
         };
     }
+    for (key, value) in shell.into_iter().filter(|(k, _)| !explicit.contains(k)) {
+        cmd.env(key, value);
+    }
     cmd
 }
 
@@ -129,12 +245,13 @@ pub fn host_vars() -> impl Iterator<Item = (OsString, OsString)> {
     apply_changes(std::env::vars_os().collect(), &child_env_changes()).into_iter()
 }
 
-/// [`std::env::var_os`] as a child should see it (see [`host_env`]).
+/// [`std::env::var_os`] as a child should see it (see [`host_env`]), the login shell's value
+/// included when this process lacks the variable.
 pub fn host_var_os(key: impl AsRef<OsStr>) -> Option<OsString> {
     let key = key.as_ref();
     match child_env_changes().into_iter().find(|(k, _)| k == key) {
         Some((_, fixed)) => fixed,
-        None => std::env::var_os(key),
+        None => std::env::var_os(key).or_else(|| shell_env().find(|(k, _)| k == key).map(|(_, v)| v)),
     }
 }
 
@@ -395,6 +512,28 @@ fn append_path_entries(path: &OsStr, extra: &OsStr) -> OsString {
 mod tests {
     use super::*;
 
+    #[cfg(unix)]
+    #[test]
+    fn kill_tree_of_reaches_what_the_child_started() {
+        use std::io::BufRead;
+        let mut cmd = Command::new("sh");
+        own_group(&mut cmd).args(["-c", "sleep 30 & echo $!; wait"]).stdout(std::process::Stdio::piped());
+        let mut child = cmd.spawn().unwrap();
+        let mut line = String::new();
+        std::io::BufReader::new(child.stdout.take().unwrap()).read_line(&mut line).unwrap();
+        let grandchild: libc::pid_t = line.trim().parse().unwrap();
+        let alive = |pid: libc::pid_t| unsafe { libc::kill(pid, 0) } == 0;
+        assert!(alive(grandchild));
+        kill_tree_of(child.id());
+        let _ = child.wait();
+        // Reparented to init once its parent is gone, which reaps it.
+        let gone = (0..100).any(|_| {
+            std::thread::sleep(Duration::from_millis(20));
+            !alive(grandchild)
+        });
+        assert!(gone, "the grandchild {grandchild} survived");
+    }
+
     #[cfg(windows)]
     #[test]
     fn user_path_reads_the_current_users_path() {
@@ -525,6 +664,15 @@ mod tests {
         assert_eq!(get("HOME"), Some(None));
         let shell: Vec<_> = shell_env().map(|(k, _)| k).collect();
         assert_eq!(shell, [OsString::from("OPENIDEA_OVERLAY_B")]);
+        // Every child gets what the login shell exports and the IDE process lacks (a Finder
+        // launch: `GOPATH`, `JAVA_HOME`...), unless the call site sets it.
+        assert_eq!(get("OPENIDEA_OVERLAY_B"), Some(Some("b".into())));
+        let mut own = Command::new("true");
+        own.env("OPENIDEA_OVERLAY_B", "call site");
+        host_env(&mut own);
+        let value = own.get_envs().find(|(n, _)| *n == "OPENIDEA_OVERLAY_B").and_then(|(_, v)| v);
+        assert_eq!(value, Some(OsStr::new("call site")));
+        assert_eq!(host_var_os("OPENIDEA_OVERLAY_B"), Some("b".into()));
         assert_eq!(host_var_os("PATH"), Some("/reloaded".into()));
         assert!(host_vars().all(|(k, _)| k != "HOME"));
         assert!(host_vars().any(|(k, v)| k == "OPENIDEA_OVERLAY_A" && v == "project"));

crates/ide-core/src/settings.rs

@@ -59,6 +59,31 @@ pub struct Settings {
     /// Build, Execution, Deployment › Run Targets.
     pub run_targets: Vec<RunTarget>,
     pub cmake: CMakeSettings,
+    /// Tools › Agents › Chat.
+    pub agents: AgentSettings,
+    /// Plugin settings (`[contributes.settings]`): plugin id → its values by key.
+    #[specta(type = BTreeMap<String, BTreeMap<String, specta_typescript::Unknown>>)]
+    pub plugins: BTreeMap<String, serde_json::Map<String, serde_json::Value>>,
+}
+
+/// What the meters in an agent task's header show.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
+#[serde(default, rename_all = "camelCase")]
+pub struct AgentSettings {
+    /// Context window use.
+    pub show_context_usage: bool,
+    /// Time the agent spent on the task.
+    pub show_work_time: bool,
+    /// The account's usage-limit windows (Claude's 5-hour and weekly limits).
+    pub show_usage_limits: bool,
+    /// What the session has cost so far, as the agent reports it.
+    pub show_cost: bool,
+}
+
+impl Default for AgentSettings {
+    fn default() -> Self {
+        Self { show_context_usage: true, show_work_time: true, show_usage_limits: true, show_cost: false }
+    }
 }
 
 /// Absent profiles retain automatic discovery for existing projects.
@@ -132,6 +157,16 @@ pub struct LanguageServerSettings {
     pub languages: Vec<String>,
     /// Files marking a workspace root for a server defined here (`pyproject.toml`).
     pub root_markers: Vec<String>,
+    /// Replaces the definition's `features`: what the server is used for
+    /// (`code-action`, `hover`, …); an empty list means everything.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[specta(optional)]
+    pub features: Option<Vec<String>>,
+    /// Replaces the definition's `code-action-kinds` (`refactor`); an empty
+    /// list keeps every kind.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[specta(optional)]
+    pub code_action_kinds: Option<Vec<String>>,
 }
 
 impl Default for LanguageServerSettings {
@@ -145,6 +180,8 @@ impl Default for LanguageServerSettings {
             settings: None,
             languages: Vec::new(),
             root_markers: Vec::new(),
+            features: None,
+            code_action_kinds: None,
         }
     }
 }
@@ -192,6 +229,8 @@ impl Default for Settings {
             deployment: DeploymentSettings::default(),
             run_targets: Vec::new(),
             cmake: CMakeSettings::default(),
+            agents: AgentSettings::default(),
+            plugins: BTreeMap::new(),
         }
     }
 }
@@ -300,7 +339,8 @@ impl Default for NotificationGroupSettings {
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
 #[serde(default, rename_all = "camelCase")]
 pub struct AppearanceSettings {
-    /// `dark` | `light` | `system` | `dark-hc` (high-contrast dark)
+    /// A built-in theme id (`light`, `dark`, `dark-hc`, …), `system` (legacy
+    /// "Sync with OS"), or a plugin's theme: `plugin:<plugin-id>/<theme-id>`.
     pub theme: String,
     pub accent: String,
     pub ui_font_size: f32,
@@ -309,6 +349,9 @@ pub struct AppearanceSettings {
     pub sync_with_os: bool,
     pub preferred_light_theme: String,
     pub preferred_dark_theme: String,
+    /// A plugin's file icon theme (`<plugin-id>/<theme-id>`); empty = the built-in icons.
+    pub file_icon_theme: String,
+    pub file_icon_theme_options: BTreeMap<String, FileIconThemeOptions>,
     /// IDE zoom in percent (50–300).
     pub zoom: u32,
     /// Apply `ui_font_family` / `ui_font_size` (otherwise the theme's).
@@ -344,6 +387,24 @@ pub struct AppearanceSettings {
 /// Main toolbar entries per side, in order: title widget ids (`project`,
 /// `vcs.branch`…) or `action:<id>`. Widgets in neither list nor `hidden`
 /// (registered later) keep their default place.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
+#[serde(default, rename_all = "camelCase")]
+pub struct FileIconThemeOptions {
+    pub groups: BTreeMap<String, bool>,
+    pub choices: BTreeMap<String, String>,
+    pub hide_files: bool,
+    pub hide_folders: bool,
+    pub hollow_folders: bool,
+    pub hide_ui_icons: bool,
+    pub hide_psi_icons: bool,
+    pub monochrome: Option<String>,
+    pub saturation: Option<u8>,
+    pub opacity: Option<u8>,
+    pub icon_size: Option<u8>,
+    pub row_height: Option<u8>,
+    pub accent: Option<String>,
+}
+
 #[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
 #[serde(default, rename_all = "camelCase")]
 pub struct MainToolbarSettings {
@@ -363,6 +424,8 @@ impl Default for AppearanceSettings {
             sync_with_os: false,
             preferred_light_theme: "light".into(),
             preferred_dark_theme: "dark".into(),
+            file_icon_theme: String::new(),
+            file_icon_theme_options: BTreeMap::new(),
             zoom: 100,
             use_custom_font: false,
             ui_font_family: "Inter".into(),
@@ -547,7 +610,8 @@ pub struct LanguagesSettings {
     pub rust: RustSettings,
     pub go: GoSettings,
     pub typescript: TypeScriptSettings,
-    pub prettier: PrettierSettings,
+    pub prettier: ExternalFormatterSettings,
+    pub oxfmt: ExternalFormatterSettings,
     pub java: JavaSettings,
     pub ruby: RubySettings,
     pub markdown: MarkdownSettings,
@@ -561,18 +625,46 @@ pub struct MarkdownSettings {
     pub preview_font_size: Option<u32>,
 }
 
+impl LanguagesSettings {
+    pub fn formatter(&self, tool: ExternalFormatter) -> &ExternalFormatterSettings {
+        match tool {
+            ExternalFormatter::Prettier => &self.prettier,
+            ExternalFormatter::Oxfmt => &self.oxfmt,
+        }
+    }
+}
+
+/// A formatter that runs outside the language servers, with its own settings group.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
+#[serde(rename_all = "lowercase")]
+pub enum ExternalFormatter {
+    Prettier,
+    Oxfmt,
+}
+
+impl ExternalFormatter {
+    /// The name of the tool in the tool registry.
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::Prettier => "prettier",
+            Self::Oxfmt => "oxfmt",
+        }
+    }
+}
+
+/// An external formatter (Prettier, oxfmt) and the languages it formats.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
 #[serde(default, rename_all = "camelCase")]
-pub struct PrettierSettings {
+pub struct ExternalFormatterSettings {
     /// Empty path: project node_modules, managed installation, then PATH.
     pub path: String,
     pub languages: Vec<String>,
-    /// Prefer Prettier even when a language server offers formatting.
+    /// Prefer this formatter even when a language server offers formatting.
     pub prefer: bool,
     pub run_on_save: bool,
 }
 
-impl Default for PrettierSettings {
+impl Default for ExternalFormatterSettings {
     fn default() -> Self {
         Self {
             path: String::new(),
@@ -621,6 +713,15 @@ impl Default for PythonSettings {
 pub struct PhpSettings {
     /// `php` CLI executable; empty = the one on `PATH`.
     pub interpreter: String,
+    /// PHP version the language server checks the code against (`7.4`); empty = from
+    /// `composer.json` (`config.platform.php`, else the lowest version `require.php` allows).
+    pub language_level: String,
+    /// Folders outside the project whose code the language server indexes too (a platform a
+    /// module extends); absolute, `~/`, or relative to the project.
+    pub include_paths: Vec<String>,
+    /// Intelephense stub sets loaded on top of its defaults and the `ext-*` entries of
+    /// `composer.json` (`wordpress`).
+    pub stubs: Vec<String>,
 }
 
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
@@ -734,6 +835,19 @@ pub struct GradleSettings {
     pub home: String,
     /// Empty = Gradle's default user home.
     pub user_home: String,
+    /// IDEA's "Build and run using": who builds and launches an Application main.
+    pub run_using: GradleRunUsing,
+}
+
+/// IDEA's "Build and run using" for Gradle builds; IDEA defaults to Gradle.
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub enum GradleRunUsing {
+    /// A `JavaExec` task on the source set's runtime classpath (`gradleRun.gradle`).
+    #[default]
+    Gradle,
+    /// The Java language server's classpath, launched by OpenIDEA.
+    Ide,
 }
 
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
@@ -756,6 +870,12 @@ pub struct MavenSettings {
     pub user_settings: String,
     /// Local repository (`-Dmaven.repo.local`); empty = from `settings.xml`.
     pub local_repository: String,
+    /// Run Maven through the Maven Daemon (`mvnd`) for faster builds. mvnd embeds
+    /// its own Maven, so `home` and the project's `mvnw` are bypassed when it is on.
+    pub daemon: bool,
+    /// Maven Daemon home (or its `mvnd` executable); empty = `$MVND_HOME`, else
+    /// `mvnd` on `PATH` / common install dirs. Only used when `daemon` is on.
+    pub mvnd_home: String,
 }
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
@@ -846,6 +966,36 @@ mod tests {
         assert_eq!(serde_json::from_value::<Settings>(value).unwrap(), settings);
     }
 
+    #[test]
+    fn file_icon_theme_options_default_empty_and_round_trip() {
+        let old: Settings = serde_json::from_str(r#"{"appearance":{"fileIconTheme":"p/t"}}"#).unwrap();
+        assert!(old.appearance.file_icon_theme_options.is_empty());
+        let json = serde_json::json!({"appearance":{"fileIconThemeOptions":{"p/t":{
+            "groups":{"tests":true},"choices":{"arrows":"plusminus"},"hideFiles":true,"hideFolders":false,"hollowFolders":true,"hideUiIcons":true,"hidePsiIcons":false,
+            "monochrome":"#546e7a","saturation":5,"opacity":80,"iconSize":20,"rowHeight":30,"accent":"#009688"}}}});
+        let settings: Settings = serde_json::from_value(json.clone()).unwrap();
+        let options = &settings.appearance.file_icon_theme_options["p/t"];
+        assert!(options.hide_files && options.hollow_folders && !options.hide_folders);
+        assert!(options.hide_ui_icons && !options.hide_psi_icons);
+        assert!(options.groups["tests"]);
+        assert_eq!(options.choices["arrows"], "plusminus");
+        assert_eq!(
+            (options.saturation, options.opacity, options.icon_size, options.row_height),
+            (Some(5), Some(80), Some(20), Some(30))
+        );
+        assert_eq!(options.monochrome.as_deref(), Some("#546e7a"));
+        assert_eq!(options.accent.as_deref(), Some("#009688"));
+        let value = serde_json::to_value(&settings).unwrap();
+        let restored: Settings = serde_json::from_value(value).unwrap();
+        assert_eq!(restored, settings);
+        let plain = serde_json::to_value(FileIconThemeOptions::default()).unwrap();
+        assert_eq!(plain["hideFiles"], false);
+        assert_eq!(plain["hideUiIcons"], false);
+        assert_eq!(plain["hidePsiIcons"], false);
+        assert_eq!(plain["monochrome"], serde_json::Value::Null);
+        assert_eq!(plain["groups"], serde_json::json!({}));
+    }
+
     #[test]
     fn ui_font_fallback_defaults_empty_and_round_trips() {
         let old: Settings = serde_json::from_str(r#"{"appearance":{"useCustomFont":true}}"#).unwrap();
@@ -875,6 +1025,20 @@ mod tests {
         }
     }
 
+    #[test]
+    fn agent_meters_default_and_round_trip() {
+        let old: Settings = serde_json::from_str(r#"{"agents":{"showCost":true}}"#).unwrap();
+        assert!(old.agents.show_cost);
+        assert!(old.agents.show_context_usage && old.agents.show_work_time && old.agents.show_usage_limits);
+        assert!(!Settings::default().agents.show_cost);
+        let mut settings = Settings::default();
+        settings.agents.show_usage_limits = false;
+        let json = serde_json::to_value(&settings).unwrap();
+        assert_eq!(json["agents"]["showUsageLimits"], false);
+        let restored: Settings = serde_json::from_value(json).unwrap();
+        assert_eq!(restored.agents, settings.agents);
+    }
+
     #[test]
     fn main_menu_style_defaults_and_round_trips() {
         let old: Settings = serde_json::from_str(r#"{"appearance":{"compactMode":true}}"#).unwrap();
@@ -943,6 +1107,17 @@ mod maven_linkage_tests {
         assert!(encoded.contains("unlinkedProjects"));
         assert_eq!(serde_json::from_str::<MavenSettings>(&encoded).unwrap(), settings);
     }
+
+    #[test]
+    fn daemon_settings_round_trip() {
+        // Old settings files predate the daemon fields; `serde(default)` keeps them loadable.
+        let old: MavenSettings = serde_json::from_str(r#"{"home":"/opt/maven"}"#).unwrap();
+        assert!(!old.daemon && old.mvnd_home.is_empty());
+        let settings = MavenSettings { daemon: true, mvnd_home: "/opt/mvnd".into(), ..old };
+        let encoded = serde_json::to_string(&settings).unwrap();
+        assert!(encoded.contains("\"daemon\":true") && encoded.contains("mvndHome"));
+        assert_eq!(serde_json::from_str::<MavenSettings>(&encoded).unwrap(), settings);
+    }
 }
 
 #[cfg(test)]
@@ -960,6 +1135,7 @@ mod gradle_settings_tests {
                 distribution,
                 home: "/gradle".into(),
                 user_home: "/cache/gradle".into(),
+                run_using: GradleRunUsing::Ide,
             };
             let restored: Settings = serde_json::from_str(&serde_json::to_string(&settings).unwrap()).unwrap();
             assert_eq!(restored.languages.java.gradle, settings.languages.java.gradle);

crates/ide-core/src/task.rs

@@ -44,6 +44,39 @@ pub fn cancel(id: TaskId) -> bool {
     }
 }
 
+/// A progress title a tool reported, made readable: a leading absolute executable path
+/// (rust-analyzer reports `/…/bin/cargo check`) shows as its program name (`cargo check`).
+pub fn display_title(title: &str) -> String {
+    let is_sep = |c: char| c == '/' || c == '\\';
+    let b = title.as_bytes();
+    let absolute = title.starts_with(is_sep)
+        || (b.len() > 2 && b[0].is_ascii_alphabetic() && b[1] == b':' && is_sep(b[2] as char));
+    if !absolute {
+        return title.to_owned();
+    }
+    // The path runs on through spaces (`Application Support/…`) while the next word still
+    // continues it; the first word without a separator, an option or a new path ends it.
+    let mut end = title.find(' ').unwrap_or(title.len());
+    while end < title.len() {
+        let rest = &title[end + 1..];
+        let word = rest.split(' ').next().unwrap_or_default();
+        if word.is_empty() || !word.contains(is_sep) || word.starts_with(is_sep) || word.starts_with('-') {
+            break;
+        }
+        end += 1 + word.len();
+    }
+    let (path, rest) = title.split_at(end);
+    let name = path.rsplit(is_sep).next().unwrap_or(path);
+    let name = [".exe", ".cmd", ".bat"]
+        .iter()
+        .find_map(|ext| {
+            let cut = name.len().checked_sub(ext.len())?;
+            (name.is_char_boundary(cut) && name[cut..].eq_ignore_ascii_case(ext)).then(|| &name[..cut])
+        })
+        .unwrap_or(name);
+    if name.is_empty() { title.to_owned() } else { format!("{name}{rest}") }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -71,4 +104,28 @@ mod tests {
         assert!(!cancel(other), "an ended task is not cancelled");
         assert_eq!(hits.load(Ordering::SeqCst), 1);
     }
+
+    #[test]
+    fn display_title_shows_a_leading_executable_path_as_its_name() {
+        for (title, shown) in [
+            ("/Users/thomas/Library/Application Support/mbx/bin/cargo check", "cargo check"),
+            ("/home/me/.cargo/bin/cargo clippy (#2)", "cargo clippy (#2)"),
+            (
+                "/opt/my tools/bin/cargo check --manifest-path /x/Cargo.toml",
+                "cargo check --manifest-path /x/Cargo.toml",
+            ),
+            (r"C:\Users\me\.cargo\bin\cargo.exe check", "cargo check"),
+            (r"C:\Program Files\Rust\bin\cargo.EXE check", "cargo check"),
+            (r"\\server\share\tools\x.cmd build", "x build"),
+            ("/usr/bin/make", "make"),
+            ("cargo check", "cargo check"),
+            ("Indexing", "Indexing"),
+            ("Building compile-time-deps", "Building compile-time-deps"),
+            ("Loading /src/app (2/3)", "Loading /src/app (2/3)"),
+            ("/", "/"),
+            ("", ""),
+        ] {
+            assert_eq!(display_title(title), shown, "{title:?}");
+        }
+    }
 }

crates/ide-dap/src/adapter.rs

@@ -8,7 +8,7 @@
 
 use ide_core::process::executable_names;
 use ide_core::{IdeError, IdeResult};
-use ide_language::{DebuggerConfig, LanguageRegistry};
+use ide_language::{DebuggerConfig, LanguageRegistry, ProgramPin};
 use std::future::Future;
 use std::path::{Path, PathBuf};
 use std::pin::Pin;
@@ -44,6 +44,8 @@ pub struct AdapterSpec {
     /// `host:port` of an adapter inside another program (the Godot editor): connected to
     /// when it accepts, else `command` is started.
     pub connect: Option<String>,
+    /// A plugin language's adapter: start exactly this approved program.
+    pub pinned: Option<ProgramPin>,
 }
 
 /// Built-in adapters used when no language definition names `adapter`.
@@ -55,6 +57,7 @@ fn builtin(adapter: &str) -> Option<DebuggerConfig> {
         transport: transport.to_owned(),
         connect: None,
         install_hint: Some(hint.to_owned()),
+        pinned: None,
     };
     Some(match adapter {
         "codelldb" => cfg(
@@ -133,6 +136,7 @@ pub fn resolve(config: &DebuggerConfig, cwd: PathBuf) -> AdapterSpec {
         env: Vec::new(),
         server_host: None,
         connect: config.connect.clone(),
+        pinned: config.pinned.clone(),
     }
 }
 
@@ -426,12 +430,20 @@ impl AdapterLauncher for ProcessLauncher {
             if is_plugin_bundle(&spec.command) {
                 return Err(not_standalone(&spec));
             }
-            let (command, cwd) = (spec.command.clone(), spec.cwd.clone());
-            let binary = tokio::task::spawn_blocking(move || resolve_binary(&command, &cwd))
-                .await
-                .ok()
-                .flatten()
-                .ok_or_else(|| missing(&spec))?;
+            let binary = match spec.pinned.clone() {
+                Some(pin) => tokio::task::spawn_blocking(move || pin.verify().map(Path::to_path_buf))
+                    .await
+                    .map_err(|e| IdeError::internal(e.to_string()))?
+                    .map_err(|e| IdeError::new(ide_core::error::ErrorKind::PermissionDenied, e))?,
+                None => {
+                    let (command, cwd) = (spec.command.clone(), spec.cwd.clone());
+                    tokio::task::spawn_blocking(move || resolve_binary(&command, &cwd))
+                        .await
+                        .ok()
+                        .flatten()
+                        .ok_or_else(|| missing(&spec))?
+                }
+            };
             let port = match spec.transport {
                 // An embedded adapter started without `${port}` listens on its usual address.
                 Transport::Tcp => match &embedded {

crates/ide-dap/src/lib.rs

@@ -212,6 +212,19 @@ pub struct Variable {
     pub evaluate_name: Option<String>,
 }
 
+/// A completion the adapter offers for an expression (DAP `completions`).
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct DebugCompletion {
+    pub label: String,
+    /// What to insert, when it differs from `label`.
+    pub text: Option<String>,
+    /// DAP item type: `method`, `field`, `variable`, `class`, `keyword`, …
+    pub kind: Option<String>,
+    pub detail: Option<String>,
+    pub sort_text: Option<String>,
+}
+
 #[derive(Clone, Copy, Debug, Serialize, Deserialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub enum StepKind {
@@ -576,11 +589,12 @@ impl DebugManager {
         if let Some(command) = custom_command(&spec.command) {
             spec.command = command;
         }
-        // debugpy: run the adapter with the debuggee's interpreter (venvs carry their own debugpy).
+        // debugpy: run the adapter with the debuggee's interpreter (venvs carry their own debugpy),
+        // or with the launcher's when the debuggee runs through a manager (`uv run python`).
         if config.adapter == "debugpy" {
-            let python = match arguments.get("python") {
-                Some(Value::String(p)) => Some(p.clone()),
-                Some(Value::Array(a)) => a.first().and_then(Value::as_str).map(str::to_owned),
+            let python = match (arguments.get("debugLauncherPython"), arguments.get("python")) {
+                (Some(Value::String(p)), _) | (_, Some(Value::String(p))) => Some(p.clone()),
+                (_, Some(Value::Array(a))) => a.first().and_then(Value::as_str).map(str::to_owned),
                 _ => None,
             };
             if let Some(python) = python {
@@ -638,8 +652,19 @@ impl DebugManager {
         {
             arguments["project"] = json!(real);
         }
-        if config.adapter == "codelldb" && arguments.get("sourceLanguages").is_none() {
-            arguments["sourceLanguages"] = json!(["rust"]);
+        if config.adapter == "codelldb" {
+            if arguments.get("sourceLanguages").is_none() {
+                arguments["sourceLanguages"] = json!(["rust"]);
+            }
+            // The Debug Console and Evaluate Expression take expressions, as with every other
+            // debugger; LLDB commands still run with a leading backtick.
+            match arguments.get_mut("_adapterSettings") {
+                None => arguments["_adapterSettings"] = json!({"consoleMode": "evaluate"}),
+                Some(Value::Object(settings)) => {
+                    settings.entry("consoleMode").or_insert_with(|| json!("evaluate"));
+                }
+                Some(_) => {}
+            }
         }
         let port = debug_server.map(|s| s.port);
         self.start_session(id, owner, config.name, config.adapter, None, config.request, arguments, spec, port).await
@@ -1157,6 +1182,47 @@ impl DebugManager {
         })
     }
 
+    /// Completions for `text` at `line` / `column` (0-based, UTF-16) in the frame's scope; none
+    /// when the adapter doesn't offer them.
+    pub async fn completions(
+        &self,
+        s: DebugSessionId,
+        frame_id: Option<i64>,
+        text: String,
+        line: u32,
+        column: u32,
+    ) -> IdeResult<Vec<DebugCompletion>> {
+        let session = self.session(s)?;
+        if !session.supports("supportsCompletionsRequest") {
+            return Ok(Vec::new());
+        }
+        let mut args = json!({ "text": text, "line": line + 1, "column": column + 1 });
+        if let Some(f) = frame_id {
+            args["frameId"] = f.into();
+        }
+        let body = session.conn.request_timeout("completions", args, REQUEST_TIMEOUT).await?;
+        let text =
+            |v: &Value, key: &str| v.get(key).and_then(Value::as_str).filter(|t| !t.is_empty()).map(str::to_owned);
+        Ok(body
+            .get("targets")
+            .and_then(Value::as_array)
+            .map(|targets| {
+                targets
+                    .iter()
+                    .filter_map(|t| {
+                        Some(DebugCompletion {
+                            label: text(t, "label")?,
+                            text: text(t, "text"),
+                            kind: text(t, "type"),
+                            detail: text(t, "detail"),
+                            sort_text: text(t, "sortText"),
+                        })
+                    })
+                    .collect()
+            })
+            .unwrap_or_default())
+    }
+
     pub async fn resume(&self, s: DebugSessionId, thread_id: i64) -> IdeResult<()> {
         let session = self.session(s)?;
         let body = session.conn.request_timeout("continue", json!({ "threadId": thread_id }), REQUEST_TIMEOUT).await?;

crates/ide-dap/src/session.rs

@@ -405,7 +405,7 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
                 let mut progress = s.progress.lock();
                 let id =
                     if done { progress.remove(&pid) } else { Some(*progress.entry(pid).or_insert_with(TaskId::next)) };
-                (id, str_("title").unwrap_or_else(|| s.name.clone()))
+                (id, str_("title").map(|t| ide_core::task::display_title(&t)).unwrap_or_else(|| s.name.clone()))
             };
             let Some(id) = id else { return };
             s.owner.sink.emit(IdeEvent::Task {

crates/ide-dap/src/tests.rs

@@ -73,6 +73,7 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
                 msg,
                 json!({
                     "supportsConfigurationDoneRequest": true,
+                    "supportsCompletionsRequest": true,
                     "supportsTerminateRequest": true,
                     "supportsSetVariable": true,
                     "supportsFunctionBreakpoints": true,
@@ -172,6 +173,14 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
                 ]})
             ),
             "evaluate" => ok!(msg, json!({"result": "42", "type": "int", "variablesReference": 0})),
+            "completions" => ok!(
+                msg,
+                json!({"targets": [
+                    {"label": "getName()", "text": "getName", "type": "method", "detail": "String"},
+                    {"label": "name", "type": "field"},
+                    {"label": ""},
+                ]})
+            ),
             "continue" => {
                 ok!(msg, json!({"allThreadsContinued": true}));
                 send!(json!({"type": "event", "event": "exited", "body": {"exitCode": 3}}));
@@ -368,6 +377,14 @@ async fn full_protocol_flow() {
     let eval = h.request("evaluate");
     assert_eq!(eval["arguments"]["context"], "watch");
     assert_eq!(eval["arguments"]["frameId"], 10);
+    let items = h.manager.completions(id, Some(10), "req.na".into(), 0, 6).await.unwrap();
+    assert_eq!(
+        items.iter().map(|c| (c.label.as_str(), c.text.as_deref(), c.kind.as_deref())).collect::<Vec<_>>(),
+        [("getName()", Some("getName"), Some("method")), ("name", None, Some("field"))]
+    );
+    let asked = h.request("completions");
+    assert_eq!((asked["arguments"]["line"].clone(), asked["arguments"]["column"].clone()), (json!(1), json!(7)));
+    assert_eq!(asked["arguments"]["frameId"], 10);
 
     // Live breakpoint updates reach the session.
     let states = h.manager.set_breakpoints(path.clone(), vec![bp(0)]).await.unwrap();
@@ -681,6 +698,37 @@ async fn js_debug_launch_gets_port_and_workspace_folder() {
     assert_eq!(launch["type"], "pwa-node");
 }
 
+/// CodeLLDB treats console input as LLDB commands unless told otherwise: Evaluate Expression
+/// and the Debug Console send expressions, so its console evaluates them. A launch
+/// configuration that picks a console mode keeps it.
+#[tokio::test]
+async fn codelldb_console_evaluates_expressions() {
+    let launch_with = |extra: Value| async move {
+        let h = harness(Script::default());
+        let config = LaunchConfig {
+            name: "demo".into(),
+            adapter: "codelldb".into(),
+            request: "launch".into(),
+            program: Some("/p/target/debug/demo".into()),
+            args: vec![],
+            cwd: Some("/p".into()),
+            env: BTreeMap::new(),
+            extra_json: Some(extra.to_string()),
+        };
+        h.start(config).await.unwrap();
+        h.request("launch")["arguments"].clone()
+    };
+    let launch = launch_with(json!({})).await;
+    assert_eq!(launch["_adapterSettings"]["consoleMode"], "evaluate");
+    assert_eq!(launch["sourceLanguages"], json!(["rust"]));
+
+    let launch =
+        launch_with(json!({"_adapterSettings": {"consoleMode": "commands", "showDisassembly": "never"}})).await;
+    assert_eq!(launch["_adapterSettings"], json!({"consoleMode": "commands", "showDisassembly": "never"}));
+    let launch = launch_with(json!({"_adapterSettings": {"showDisassembly": "never"}})).await;
+    assert_eq!(launch["_adapterSettings"], json!({"consoleMode": "evaluate", "showDisassembly": "never"}));
+}
+
 /// An adapter that is already listening (java-debug inside jdtls): the client
 /// connects over TCP to the `debugServer` port instead of spawning anything.
 #[tokio::test]
@@ -906,6 +954,7 @@ fn godot_registry(port: u16, command: &str, args: &[&str]) -> Arc<LanguageRegist
         ui_mode: None,
         framework_ui_modes: Vec::new(),
         formatter: None,
+        scratch_template: None,
         tree_sitter: None,
         language_servers: vec![],
         debugger: Some(ide_language::DebuggerConfig {
@@ -915,6 +964,7 @@ fn godot_registry(port: u16, command: &str, args: &[&str]) -> Arc<LanguageRegist
             transport: "tcp".into(),
             connect: Some(format!("127.0.0.1:{port}")),
             install_hint: Some("Open the project in the Godot editor".into()),
+            pinned: None,
         }),
     };
     Arc::new(LanguageRegistry::from_configs(vec![lang]))
@@ -1147,3 +1197,58 @@ async fn java_stack_frames_without_breakpoints_normalize_windows_paths() {
         h.manager.stop(id).await.unwrap();
     }
 }
+
+/// A built-in language definition (GDScript) shipped by a plugin
+/// instead: its debugger starts the program approved for the plugin's
+/// `process:godot` grant, and refuses once that file changed.
+#[cfg(unix)]
+#[tokio::test]
+async fn a_plugin_language_runs_its_debug_adapter_from_the_approved_program() {
+    use ide_language::ProgramPin;
+    use ide_language::plugin_point::{PluginLanguages, parse_definition};
+    use std::os::unix::fs::PermissionsExt;
+
+    let dir = std::env::temp_dir().join(format!("openidea-plugin-dap-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    // Stands in for `godot --headless --editor …`.
+    let program = dir.join("godot");
+    std::fs::write(&program, "#!/bin/sh\nexec sleep 30\n").unwrap();
+    std::fs::set_permissions(&program, std::fs::Permissions::from_mode(0o755)).unwrap();
+
+    let port = std::net::TcpListener::bind(("127.0.0.1", 0)).unwrap().local_addr().unwrap().port();
+    let mut gdscript = parse_definition(include_str!("../../../languages/gdscript.toml")).unwrap();
+    let debugger = gdscript.debugger.as_mut().unwrap();
+    debugger.args.clear();
+    debugger.connect = Some(format!("127.0.0.1:{port}"));
+
+    // No built-in GDScript: it comes from the plugin.
+    let registry = Arc::new(LanguageRegistry::from_configs(Vec::new()));
+    let store = PluginLanguages::new();
+    registry.attach_plugins(store.clone());
+    let pin = ProgramPin::approve(&program).unwrap();
+    store.set_process_policy(Arc::new(move |plugin, cap| {
+        (plugin == "acme.godot" && cap.to_string() == "process:godot").then(|| pin.clone())
+    }));
+    let _language = store.add("acme.godot".into(), gdscript);
+
+    let log: Log = Arc::default();
+    let server_log = log.clone();
+    tokio::spawn(async move {
+        tokio::time::sleep(std::time::Duration::from_millis(300)).await;
+        let listener = tokio::net::TcpListener::bind(("127.0.0.1", port)).await.unwrap();
+        let (stream, _) = listener.accept().await.unwrap();
+        fake_adapter(stream, server_log, Script::default()).await;
+    });
+    let (owner, _events) = recording_owner("main");
+    let manager = DebugManager::new(registry.clone());
+    let id = manager.start(godot_launch(&dir), owner).await.unwrap();
+    assert!(log.lock().iter().any(|m| m["command"] == "launch"));
+    manager.stop(id).await.unwrap();
+
+    // Replaced after approval: refused before anything starts.
+    std::fs::write(&program, "#!/bin/sh\nexec sleep 31\n").unwrap();
+    let (owner, _events) = recording_owner("main");
+    let err = manager.start(godot_launch(&dir), owner).await.unwrap_err();
+    assert_eq!(err.kind, ide_core::error::ErrorKind::PermissionDenied, "{}", err.message);
+    let _ = std::fs::remove_dir_all(&dir);
+}

crates/ide-db/Cargo.toml

@@ -8,7 +8,7 @@ license.workspace = true
 [dependencies]
 ide-core.workspace = true
 serde.workspace = true
-serde_json.workspace = true
+serde_json = { workspace = true, features = ["raw_value"] }
 specta.workspace = true
 toml.workspace = true
 tokio.workspace = true
@@ -21,6 +21,10 @@ bb8.workspace = true
 tokio-util = { workspace = true, features = ["compat"] }
 dirs.workspace = true
 ide-ssh.workspace = true
+ide-http.workspace = true
+reqwest = { workspace = true, features = ["query"] }
+rustls.workspace = true
+uuid.workspace = true
 
 [dev-dependencies]
 tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }

crates/ide-db/src/clickhouse.rs

@@ -0,0 +1,844 @@
+use crate::conn::{QueryResult, ResultColumn, Setup};
+use crate::source::{DataSource, DbSslMode, DbTxMode};
+use ide_core::{CancellationToken, IdeError, IdeResult, error::ErrorKind};
+use parking_lot::RwLock;
+use reqwest::{Client, RequestBuilder, StatusCode, Url};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+use tokio::sync::Mutex;
+
+#[derive(Clone)]
+pub struct ClickhousePool(Arc<State>);
+
+struct State {
+    client: RwLock<Option<Client>>,
+    endpoint: Url,
+    user: String,
+    password: String,
+    database: String,
+    settings: Vec<(String, String)>,
+    read_only: bool,
+    session_id: String,
+    session: Mutex<bool>,
+    closed: CancellationToken,
+}
+
+/// The response format: a names line, a types line, then one JSON array per row, so rows past
+/// the grid's limit are skipped without being parsed.
+const FORMAT: &str = "JSONCompactEachRowWithNamesAndTypes";
+
+pub(crate) fn transaction_error() -> IdeError {
+    IdeError::invalid("ClickHouse HTTP does not support SQL transactions; use auto-commit and run writes directly")
+}
+
+impl ClickhousePool {
+    pub(crate) async fn connect(source: &DataSource, password: Option<&str>, setup: Setup) -> IdeResult<Self> {
+        if source.options.transaction == DbTxMode::Manual {
+            return Err(transaction_error());
+        }
+        for (name, _) in &setup.params {
+            if reserved_setting(name) {
+                return Err(IdeError::invalid(format!("ClickHouse HTTP manages the {name} setting")));
+            }
+        }
+        let secure = matches!(source.ssl, DbSslMode::Require | DbSslMode::VerifyCa | DbSslMode::VerifyFull);
+        let tls_files = [&source.ssl_ca_file, &source.ssl_cert_file, &source.ssl_key_file];
+        if !secure && tls_files.iter().any(|p| !p.trim().is_empty()) {
+            return Err(IdeError::invalid(
+                "ClickHouse TLS certificate files require an SSL mode of Require, Verify CA, or Verify Full",
+            ));
+        }
+        let host = source.host.trim();
+        if host.is_empty() || host.contains(['/', '@', '?', '#']) {
+            return Err(IdeError::invalid("ClickHouse host must contain only a hostname or IP address"));
+        }
+        let host = if host.contains(':') && !host.starts_with('[') { format!("[{host}]") } else { host.to_owned() };
+        let scheme = if secure { "https" } else { "http" };
+        let port = source.port.unwrap_or(if secure { 8443 } else { 8123 });
+        let endpoint = Url::parse(&format!("{scheme}://{host}:{port}/"))
+            .map_err(|_| IdeError::invalid("invalid ClickHouse HTTP host or port"))?;
+        let timeout = setup.connect_timeout.unwrap_or(Duration::from_secs(30));
+        let _ = rustls::crypto::ring::default_provider().install_default();
+        let mut builder = Client::builder()
+            .connect_timeout(timeout)
+            .pool_max_idle_per_host(4)
+            .redirect(reqwest::redirect::Policy::none())
+            .user_agent(concat!("OpenIDEA/", env!("CARGO_PKG_VERSION")));
+        let ca = source.ssl_ca_file.trim();
+        if !ca.is_empty() {
+            let pem = read_pem(ca, "CA certificate")?;
+            let certificates = reqwest::Certificate::from_pem_bundle(&pem)
+                .map_err(|_| IdeError::invalid("invalid ClickHouse CA certificate PEM"))?;
+            if certificates.is_empty() {
+                return Err(IdeError::invalid("ClickHouse CA certificate PEM contains no certificates"));
+            }
+            builder = builder.tls_certs_only(certificates);
+        }
+        if source.ssl == DbSslMode::VerifyCa {
+            if ca.is_empty() {
+                return Err(IdeError::invalid("ClickHouse Verify CA requires a CA certificate file"));
+            }
+            builder = builder.tls_danger_accept_invalid_hostnames(true);
+        }
+        let cert = source.ssl_cert_file.trim();
+        let key = source.ssl_key_file.trim();
+        if cert.is_empty() != key.is_empty() {
+            return Err(IdeError::invalid("ClickHouse client TLS requires both certificate and key files"));
+        }
+        if !cert.is_empty() {
+            let mut pem = read_pem(cert, "client certificate")?;
+            pem.push(b'\n');
+            pem.extend(read_pem(key, "client key")?);
+            let identity = reqwest::Identity::from_pem(&pem)
+                .map_err(|_| IdeError::invalid("invalid ClickHouse client certificate or key PEM"))?;
+            builder = builder.identity(identity);
+        }
+        let proxy = ide_core::proxy_settings::proxy();
+        let client = ide_http::client::with_proxy(builder, &proxy).build().map_err(http_error)?;
+        let database = if source.options.default_schema.trim().is_empty() {
+            source.database.trim()
+        } else {
+            source.options.default_schema.trim()
+        };
+        let pool = Self(Arc::new(State {
+            client: RwLock::new(Some(client)),
+            endpoint,
+            user: if source.user.is_empty() { "default".into() } else { source.user.clone() },
+            password: password.unwrap_or_default().to_owned(),
+            database: if database.is_empty() { "default".into() } else { database.into() },
+            settings: setup.params,
+            read_only: source.read_only,
+            session_id: uuid::Uuid::new_v4().to_string(),
+            session: Mutex::new(false),
+            closed: CancellationToken::new(),
+        }));
+        let cancel = CancellationToken::new();
+        let initialize = async {
+            pool.execute("SELECT 1", 1, &cancel).await?;
+            for sql in setup.statements {
+                pool.execute(&sql, 0, &cancel).await?;
+            }
+            Ok(pool.clone())
+        };
+        tokio::pin!(initialize);
+        tokio::select! {
+            result = &mut initialize => {
+                if result.is_err() {
+                    pool.close();
+                }
+                result
+            },
+            () = tokio::time::sleep(timeout) => {
+                cancel.cancel();
+                let _ = initialize.await;
+                pool.close();
+                Err(IdeError::new(ErrorKind::TimedOut, "timed out connecting to ClickHouse HTTP"))
+            }
+        }
+    }
+
+    pub fn close(&self) {
+        self.0.closed.cancel();
+        self.0.client.write().take();
+    }
+
+    pub fn is_closed(&self) -> bool {
+        self.0.closed.is_cancelled()
+    }
+
+    fn client(&self) -> IdeResult<Client> {
+        self.0.client.read().clone().ok_or_else(|| IdeError::new(ErrorKind::Io, "ClickHouse connection is closed"))
+    }
+
+    fn request(&self, client: &Client, query_id: &str, max_rows: usize, initialized: bool) -> RequestBuilder {
+        let mut request = client
+            .post(self.0.endpoint.clone())
+            .basic_auth(&self.0.user, Some(&self.0.password))
+            .header(reqwest::header::CONTENT_TYPE, "text/plain; charset=utf-8")
+            .query(&self.0.settings)
+            .query(&[
+                ("session_id", self.0.session_id.clone()),
+                ("session_timeout", "3600".into()),
+                ("query_id", query_id.to_owned()),
+                ("default_format", FORMAT.into()),
+                ("output_format_json_quote_denormals", "1".into()),
+                ("max_result_rows", max_rows.saturating_add(1).to_string()),
+                ("result_overflow_mode", "break".into()),
+            ]);
+        if initialized {
+            request = request.query(&[("session_check", "1")]);
+        } else {
+            request = request.query(&[("database", &self.0.database)]);
+        }
+        if self.0.read_only {
+            request = request.query(&[("readonly", "1")]);
+        }
+        request
+    }
+
+    pub async fn execute(&self, sql: &str, max_rows: usize, cancel: &CancellationToken) -> IdeResult<QueryResult> {
+        if transaction_statement(sql) {
+            return Err(transaction_error());
+        }
+        let mut session = tokio::select! {
+            biased;
+            () = cancel.cancelled() => return Err(IdeError::cancelled()),
+            () = self.0.closed.cancelled() => return Err(IdeError::new(ErrorKind::Io, "ClickHouse connection is closed")),
+            session = self.0.session.lock() => session,
+        };
+        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 started = Instant::now();
+        let fetch = async {
+            let mut response = request.send().await.map_err(http_error)?;
+            let execution_ms = started.elapsed().as_secs_f64() * 1000.0;
+            let status = response.status();
+            let header = |name: &str| response.headers().get(name).and_then(|v| v.to_str().ok()).map(str::to_owned);
+            let exception_code = header("X-ClickHouse-Exception-Code");
+            let format = header("X-ClickHouse-Format");
+            let affected = header("X-ClickHouse-Summary")
+                .and_then(|v| serde_json::from_str::<serde_json::Value>(&v).ok())
+                .and_then(|v| {
+                    v.get("written_rows")
+                        .and_then(|n| n.as_str().and_then(|n| n.parse::<u64>().ok()).or_else(|| n.as_u64()))
+                });
+            if !status.is_success() || exception_code.as_deref().is_some_and(|code| code != "0") {
+                let body = response.bytes().await.map_err(http_error)?;
+                return Err(self.server_error(status, exception_code.as_deref(), &body));
+            }
+            let (columns, rows, has_more) = if format.as_deref().is_some_and(|f| f != FORMAT) {
+                let body = response.bytes().await.map_err(http_error)?;
+                if !body.iter().all(u8::is_ascii_whitespace) {
+                    return Err(IdeError::invalid(
+                        "ClickHouse result grids need the default output format; remove the query's FORMAT clause",
+                    ));
+                }
+                (Vec::new(), Vec::new(), false)
+            } else {
+                let mut reader = RowReader::new(max_rows);
+                while let Some(chunk) = response.chunk().await.map_err(http_error)? {
+                    reader.push(&chunk)?;
+                }
+                reader.finish().map_err(|error| self.redact_error(error))?
+            };
+            let affected = if columns.is_empty() { affected.map(|n| n as f64) } else { None };
+            Ok(QueryResult {
+                statement: sql.to_owned(),
+                columns,
+                rows,
+                affected,
+                has_more,
+                elapsed_ms: started.elapsed().as_secs_f64() * 1000.0,
+                execution_ms,
+            })
+        };
+        let result = tokio::select! {
+            biased;
+            () = cancel.cancelled() => None,
+            () = self.0.closed.cancelled() => None,
+            result = fetch => Some(result),
+        };
+        match result {
+            Some(result) => {
+                if result.is_ok() {
+                    *session = true;
+                }
+                result
+            }
+            None => {
+                let killed = self.kill(&client, &query_id).await;
+                match killed {
+                    Ok(()) => Err(IdeError::cancelled()),
+                    Err(error) => Err(IdeError::new(
+                        ErrorKind::Cancelled,
+                        format!("cancelled locally; ClickHouse server cancellation failed: {}", error.message),
+                    )),
+                }
+            }
+        }
+    }
+
+    async fn kill(&self, client: &Client, query_id: &str) -> IdeResult<()> {
+        let response = client
+            .post(self.0.endpoint.clone())
+            .basic_auth(&self.0.user, Some(&self.0.password))
+            .timeout(Duration::from_secs(3))
+            .body(format!("KILL QUERY WHERE query_id = '{query_id}' SYNC"))
+            .send()
+            .await
+            .map_err(http_error)?;
+        let status = response.status();
+        let code = response
+            .headers()
+            .get("X-ClickHouse-Exception-Code")
+            .and_then(|value| value.to_str().ok())
+            .map(str::to_owned);
+        let body = response.bytes().await.map_err(http_error)?;
+        if status.is_success() && !code.as_deref().is_some_and(|code| code != "0") && !body.starts_with(b"Code:") {
+            Ok(())
+        } else {
+            Err(self.server_error(status, code.as_deref(), &body))
+        }
+    }
+
+    fn redact_error(&self, mut error: IdeError) -> IdeError {
+        if !self.0.password.is_empty() {
+            error.message = error.message.replace(&self.0.password, "[redacted]");
+        }
+        error
+    }
+
+    fn server_error(&self, status: StatusCode, code: Option<&str>, body: &[u8]) -> IdeError {
+        let message = String::from_utf8_lossy(body);
+        let message: String = exception_text(&message).chars().take(16_384).collect();
+        let auth = matches!(status, StatusCode::UNAUTHORIZED | StatusCode::FORBIDDEN)
+            || matches!(code, Some("193" | "194" | "195" | "516" | "497"));
+        let detail = if message.is_empty() { status.canonical_reason().unwrap_or("request failed") } else { &message };
+        let detail = if detail.contains("SESSION_NOT_FOUND") || detail.contains("Session not found") {
+            "ClickHouse HTTP session expired; reconnect to restore session settings"
+        } else {
+            detail
+        };
+        self.redact_error(IdeError::new(
+            if auth { ErrorKind::PermissionDenied } else { ErrorKind::InvalidInput },
+            format!("ClickHouse HTTP {}: {detail}", status.as_u16()),
+        ))
+    }
+}
+
+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
+/// starts the exception ClickHouse writes when a query fails mid-stream.
+struct RowReader {
+    max_rows: usize,
+    pending: Vec<u8>,
+    names: Option<Vec<String>>,
+    types: Option<Vec<String>>,
+    rows: Vec<Vec<Option<String>>>,
+    more: bool,
+    exception: Option<String>,
+}
+
+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 push(&mut self, chunk: &[u8]) -> IdeResult<()> {
+        self.pending.extend_from_slice(chunk);
+        let buffer = std::mem::take(&mut self.pending);
+        let mut start = 0;
+        while let Some(end) = buffer[start..].iter().position(|&b| b == b'\n') {
+            self.line(&buffer[start..start + end])?;
+            start += end + 1;
+        }
+        self.pending = buffer[start..].to_vec();
+        Ok(())
+    }
+
+    fn line(&mut self, line: &[u8]) -> IdeResult<()> {
+        if let Some(exception) = &mut self.exception {
+            if exception.len() < 16_384 {
+                exception.push_str(&String::from_utf8_lossy(line));
+                exception.push('\n');
+            }
+            return Ok(());
+        }
+        let text = line.trim_ascii();
+        if text.is_empty() {
+            return Ok(());
+        }
+        if text[0] != b'[' {
+            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(());
+        }
+        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)));
+            return Ok(());
+        };
+        let protocol = |message: String| IdeError::new(ErrorKind::Protocol, message);
+        let header = |values: Vec<Box<serde_json::value::RawValue>>| {
+            values
+                .iter()
+                .map(|v| serde_json::from_str::<String>(v.get()))
+                .collect::<Result<Vec<_>, _>>()
+                .map_err(|e| protocol(format!("invalid ClickHouse result header: {e}")))
+        };
+        let Some(names) = &self.names else {
+            self.names = Some(header(values)?);
+            return Ok(());
+        };
+        if self.types.is_none() {
+            self.types = Some(header(values)?);
+            return Ok(());
+        }
+        if values.len() != names.len() {
+            return Err(protocol("ClickHouse result row width does not match its metadata".into()));
+        }
+        let row = values
+            .into_iter()
+            .map(|value| {
+                let text = value.get();
+                if text == "null" {
+                    Ok(None)
+                } else if text.starts_with('"') {
+                    serde_json::from_str::<String>(text).map(Some).map_err(|e| protocol(e.to_string()))
+                } else {
+                    Ok(Some(text.to_owned()))
+                }
+            })
+            .collect::<IdeResult<_>>()?;
+        self.rows.push(row);
+        Ok(())
+    }
+
+    fn finish(mut self) -> IdeResult<DecodedResult> {
+        let rest = std::mem::take(&mut self.pending);
+        self.line(&rest)?;
+        if let Some(exception) = self.exception {
+            return Err(IdeError::invalid(format!("ClickHouse: {}", exception_text(&exception))));
+        }
+        let Some(names) = self.names else { return Ok((Vec::new(), Vec::new(), false)) };
+        let types = self.types.unwrap_or_default();
+        if types.len() != names.len() {
+            return Err(IdeError::new(ErrorKind::Protocol, "ClickHouse result types do not match its columns"));
+        }
+        let columns = names.into_iter().zip(types).map(|(name, type_name)| ResultColumn { name, type_name }).collect();
+        Ok((columns, self.rows, self.more))
+    }
+}
+
+/// The server's message in a failed response: rows already streamed and the
+/// `__exception__` block markers ClickHouse wraps a mid-stream error in are dropped.
+fn exception_text(body: &str) -> &str {
+    let Some(at) = body.find("Code:") else { return body.trim() };
+    let text = &body[at..];
+    match text.find("\n__exception__") {
+        // The line before the closing marker is `<length> <tag>`.
+        Some(end) => text[..end].trim_end().rsplit_once('\n').map_or(text[..end].trim(), |(message, _)| message.trim()),
+        None => text.trim(),
+    }
+}
+
+fn http_error(error: reqwest::Error) -> IdeError {
+    use std::error::Error;
+    let kind = if error.is_timeout() { ErrorKind::TimedOut } else { ErrorKind::Io };
+    let error = error.without_url();
+    let mut message = error.to_string();
+    let mut source = error.source();
+    while let Some(error) = source {
+        let detail = error.to_string();
+        if !message.contains(&detail) {
+            message.push_str(": ");
+            message.push_str(&detail);
+        }
+        source = error.source();
+    }
+    IdeError::new(kind, format!("ClickHouse HTTP: {message}"))
+}
+
+fn read_pem(path: &str, label: &str) -> IdeResult<Vec<u8>> {
+    std::fs::read(ide_ssh::expand(path))
+        .map_err(|error| IdeError::new(ErrorKind::Io, format!("cannot read ClickHouse {label}: {error}")))
+}
+
+fn reserved_setting(name: &str) -> bool {
+    let name = name.to_ascii_lowercase();
+    name.starts_with("output_format_json_")
+        || matches!(
+            name.as_str(),
+            "user"
+                | "password"
+                | "query"
+                | "database"
+                | "session_id"
+                | "session_check"
+                | "session_timeout"
+                | "query_id"
+                | "default_format"
+                | "max_result_rows"
+                | "result_overflow_mode"
+                | "readonly"
+        )
+}
+
+fn transaction_statement(sql: &str) -> bool {
+    let mut sql = sql.trim_start();
+    loop {
+        if let Some(rest) = sql.strip_prefix("--").or_else(|| sql.strip_prefix('#')) {
+            sql = rest.split_once('\n').map_or("", |(_, rest)| rest).trim_start();
+        } else if let Some(rest) = sql.strip_prefix("/*") {
+            sql = rest.split_once("*/").map_or("", |(_, rest)| rest).trim_start();
+        } else {
+            break;
+        }
+    }
+    let mut words = sql.split(|c: char| !c.is_ascii_alphanumeric() && c != '_').filter(|s| !s.is_empty());
+    let first = words.next().unwrap_or_default();
+    ["BEGIN", "COMMIT", "ROLLBACK", "SAVEPOINT", "RELEASE"].iter().any(|s| first.eq_ignore_ascii_case(s))
+        || (first.eq_ignore_ascii_case("START") && words.next().is_some_and(|s| s.eq_ignore_ascii_case("TRANSACTION")))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::conn::Pool;
+    use crate::source::{DbDriver, DbOptions, DbProperty};
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+    const ONE: &str = "[\"1\"]\n[\"UInt8\"]\n[1]\n";
+
+    async fn read_request(stream: &mut tokio::net::TcpStream) -> String {
+        let mut bytes = Vec::new();
+        let mut buffer = [0; 4096];
+        loop {
+            let count = tokio::time::timeout(Duration::from_secs(5), stream.read(&mut buffer)).await.unwrap().unwrap();
+            assert!(count > 0, "request ended early");
+            bytes.extend_from_slice(&buffer[..count]);
+            if let Some(end) = bytes.windows(4).position(|s| s == b"\r\n\r\n") {
+                let header = String::from_utf8_lossy(&bytes[..end]);
+                let length: usize = header
+                    .lines()
+                    .find_map(|line| {
+                        line.to_ascii_lowercase().strip_prefix("content-length:").map(|v| v.trim().parse().unwrap())
+                    })
+                    .unwrap_or(0);
+                if bytes.len() >= end + 4 + length {
+                    return String::from_utf8(bytes).unwrap();
+                }
+            }
+        }
+    }
+
+    async fn reply(stream: &mut tokio::net::TcpStream, status: &str, headers: &str, body: &str) {
+        let response =
+            format!("HTTP/1.1 {status}\r\nContent-Length: {}\r\nConnection: close\r\n{headers}\r\n{body}", body.len());
+        stream.write_all(response.as_bytes()).await.unwrap();
+    }
+
+    async fn server(
+        responses: Vec<(&'static str, &'static str, &'static str)>,
+    ) -> (u16, tokio::task::JoinHandle<Vec<String>>) {
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let port = listener.local_addr().unwrap().port();
+        let task = tokio::spawn(async move {
+            let mut requests = Vec::new();
+            for (status, headers, body) in responses {
+                let (mut stream, _) =
+                    tokio::time::timeout(Duration::from_secs(5), listener.accept()).await.unwrap().unwrap();
+                requests.push(read_request(&mut stream).await);
+                reply(&mut stream, status, headers, body).await;
+            }
+            requests
+        });
+        (port, task)
+    }
+
+    fn source(port: u16) -> DataSource {
+        DataSource { driver: DbDriver::Clickhouse, host: "127.0.0.1".into(), port: Some(port), ..Default::default() }
+    }
+
+    fn decode(body: &[u8], max_rows: usize, chunk: usize) -> IdeResult<DecodedResult> {
+        let mut reader = RowReader::new(max_rows);
+        for part in body.chunks(chunk) {
+            reader.push(part)?;
+        }
+        reader.finish()
+    }
+
+    #[test]
+    fn rows_preserve_precision_nulls_and_strings_across_chunks() {
+        let body = concat!(
+            r#"["n", "d", "v", "v", "v"]"#,
+            "\n",
+            r#"["UInt64", "Decimal(38, 9)", "Nullable(String)", "Nullable(String)", "Nullable(String)"]"#,
+            "\n",
+            r#"[18446744073709551615, 12345678901234567890.123456789, null, "null", "ᴺᵁᴸᴸ"]"#,
+        );
+        for chunk in [1, 7, body.len()] {
+            let (columns, rows, more) = decode(body.as_bytes(), 1, chunk).unwrap();
+            assert_eq!(columns.len(), 5);
+            assert_eq!(columns[1].type_name, "Decimal(38, 9)");
+            assert_eq!(
+                rows[0],
+                vec![
+                    Some("18446744073709551615".into()),
+                    Some("12345678901234567890.123456789".into()),
+                    None,
+                    Some("null".into()),
+                    Some("ᴺᵁᴸᴸ".into()),
+                ]
+            );
+            assert!(!more);
+        }
+        let (columns, rows, more) = decode(b"[\"x\"]\n[\"String\"]\n", 0, 64).unwrap();
+        assert_eq!(columns[0].name, "x");
+        assert!(rows.is_empty() && !more);
+        assert_eq!(decode(b"", 5, 64).unwrap().0.len(), 0);
+        assert!(decode(b"[\"x\"]\n[\"UInt8\"]\n[1, 2]\n", 1, 64).is_err());
+    }
+
+    #[test]
+    fn rows_past_the_limit_are_skipped_but_a_later_exception_still_fails() {
+        let mut body = String::from("[\"n\"]\n[\"UInt64\"]\n");
+        for n in 0..1000 {
+            body.push_str(&format!("[{n}]\n"));
+        }
+        let (_, rows, more) = decode(body.as_bytes(), 2, 4096).unwrap();
+        assert_eq!(rows, vec![vec![Some("0".into())], vec![Some("1".into())]]);
+        assert!(more);
+        body.push_str("\n__exception__\nabcdefgh\nCode: 395. DB::Exception: Value passed to 'throwIf' is non-zero\n");
+        body.push_str("62 abcdefgh\n__exception__\n");
+        let error = decode(body.as_bytes(), 2, 4096).unwrap_err();
+        assert_eq!(error.message, "ClickHouse: Code: 395. DB::Exception: Value passed to 'throwIf' is non-zero");
+        let multiline = "Code: 62. DB::Exception: Syntax error\nat line 2";
+        assert_eq!(exception_text(multiline), multiline);
+    }
+
+    #[tokio::test]
+    async fn http_requests_use_auth_settings_limits_and_a_shared_session() {
+        let (port, requests) = server(vec![
+            ("200 OK", "X-ClickHouse-Format: JSONCompactEachRowWithNamesAndTypes\r\n", ONE),
+            ("200 OK", "", ""),
+            (
+                "200 OK",
+                "X-ClickHouse-Format: JSONCompactEachRowWithNamesAndTypes\r\n",
+                "[\"n\"]\n[\"UInt64\"]\n[\"1\"]\n[\"2\"]\n[\"3\"]\n",
+            ),
+        ])
+        .await;
+        let source = DataSource {
+            user: "reader".into(),
+            read_only: true,
+            options: DbOptions { default_schema: "analytics".into(), time_zone: "UTC".into(), ..Default::default() },
+            properties: vec![DbProperty { name: "max_threads".into(), value: "2".into() }],
+            ..source(port)
+        };
+        let pool = Pool::connect(&source, Some("mock-password"), None).await.unwrap();
+        pool.execute("USE other", 0, &CancellationToken::new()).await.unwrap();
+        let result = pool.execute("SELECT number FROM numbers(3)", 1, &CancellationToken::new()).await.unwrap();
+        assert_eq!(result.rows, vec![vec![Some("1".into())]]);
+        assert!(result.has_more && result.affected.is_none());
+        let requests = requests.await.unwrap();
+        let target = |request: &String| {
+            Url::parse(&format!(
+                "http://localhost{}",
+                request.lines().next().unwrap().split_whitespace().nth(1).unwrap()
+            ))
+            .unwrap()
+        };
+        let urls: Vec<_> = requests.iter().map(target).collect();
+        let value = |url: &Url, key: &str| url.query_pairs().find(|(k, _)| k == key).map(|(_, v)| v.into_owned());
+        assert_eq!(value(&urls[0], "database").as_deref(), Some("analytics"));
+        assert_eq!(value(&urls[1], "database"), None);
+        assert_eq!(value(&urls[1], "session_check").as_deref(), Some("1"));
+        assert_eq!(value(&urls[0], "session_id"), value(&urls[2], "session_id"));
+        assert_ne!(value(&urls[0], "query_id"), value(&urls[2], "query_id"));
+        assert_eq!(value(&urls[2], "max_result_rows").as_deref(), Some("2"));
+        for (request, url) in requests.iter().zip(&urls) {
+            assert!(request.starts_with("POST /?"));
+            assert!(request.contains("Basic cmVhZGVyOm1vY2stcGFzc3dvcmQ="));
+            assert!(!url.as_str().contains("reader") && !url.as_str().contains("mock-password"));
+            assert_eq!(value(url, "readonly").as_deref(), Some("1"));
+            assert_eq!(value(url, "session_timezone").as_deref(), Some("UTC"));
+            assert_eq!(value(url, "max_threads").as_deref(), Some("2"));
+        }
+        assert!(requests[0].ends_with("SELECT 1"));
+        assert!(pool.transaction(&[]).await.is_err());
+        let cancel = CancellationToken::new();
+        cancel.cancel();
+        assert_eq!(pool.execute("SELECT 1", 1, &cancel).await.unwrap_err().kind, ErrorKind::Cancelled);
+        pool.close().await;
+        assert!(pool.is_closed());
+        assert!(pool.execute("SELECT 1", 1, &CancellationToken::new()).await.is_err());
+    }
+
+    #[tokio::test]
+    async fn sequential_queries_reuse_the_http_connection() {
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let port = listener.local_addr().unwrap().port();
+        let task = tokio::spawn(async move {
+            let (mut stream, _) = listener.accept().await.unwrap();
+            for _ in 0..2 {
+                read_request(&mut stream).await;
+                let response = format!("HTTP/1.1 200 OK\r\nContent-Length: {}\r\n\r\n{ONE}", ONE.len());
+                stream.write_all(response.as_bytes()).await.unwrap();
+            }
+        });
+        let pool = Pool::connect(&source(port), None, None).await.unwrap();
+        assert_eq!(
+            pool.execute("SELECT 1", 1, &CancellationToken::new()).await.unwrap().rows,
+            vec![vec![Some("1".into())]]
+        );
+        task.await.unwrap();
+    }
+
+    #[tokio::test]
+    async fn server_errors_keep_details_and_hide_passwords() {
+        let (port, requests) = server(vec![(
+            "403 Forbidden",
+            "X-ClickHouse-Exception-Code: 516\r\n",
+            "Code: 516. DB::Exception: bad mock-password",
+        )])
+        .await;
+        let error = match Pool::connect(&source(port), Some("mock-password"), None).await {
+            Ok(_) => panic!("expected login failure"),
+            Err(error) => error,
+        };
+        assert_eq!(error.kind, ErrorKind::PermissionDenied);
+        assert!(error.message.contains("516") && error.message.contains("[redacted]"));
+        assert!(!error.message.contains("mock-password"));
+        requests.await.unwrap();
+        let (port, requests) = server(vec![("200 OK", "", "Code: 241. DB::Exception: memory limit")]).await;
+        let error = match Pool::connect(&source(port), None, None).await {
+            Ok(_) => panic!("expected late query failure"),
+            Err(error) => error,
+        };
+        assert!(error.message.contains("memory limit"));
+        requests.await.unwrap();
+        let (port, requests) = server(vec![(
+            "500 Internal Server Error",
+            "X-ClickHouse-Exception-Code: 395\r\n",
+            "[\"1\"]\n[\"UInt8\"]\n[1]\n\n__exception__\ntag\nCode: 395. DB::Exception: thrown\n32 tag\n__exception__\n",
+        )])
+        .await;
+        let error = match Pool::connect(&source(port), None, None).await {
+            Ok(_) => panic!("expected mid-stream failure"),
+            Err(error) => error,
+        };
+        assert_eq!(error.message, "ClickHouse HTTP 500: Code: 395. DB::Exception: thrown");
+        requests.await.unwrap();
+    }
+
+    #[tokio::test]
+    async fn cancellation_sends_kill_outside_the_busy_session() {
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let port = listener.local_addr().unwrap().port();
+        let (started, received) = tokio::sync::oneshot::channel();
+        let server = tokio::spawn(async move {
+            let (mut health, _) = listener.accept().await.unwrap();
+            read_request(&mut health).await;
+            reply(&mut health, "200 OK", "", ONE).await;
+            drop(health);
+            let (mut query, _) = listener.accept().await.unwrap();
+            let request = read_request(&mut query).await;
+            started.send(()).unwrap();
+            let (mut kill, _) = tokio::time::timeout(Duration::from_secs(5), listener.accept()).await.unwrap().unwrap();
+            let kill_request = read_request(&mut kill).await;
+            reply(&mut kill, "200 OK", "", "").await;
+            (request, kill_request)
+        });
+        let pool = Pool::connect(&source(port), None, None).await.unwrap();
+        let cancel = CancellationToken::new();
+        let query = pool.execute("SELECT sleep(30)", 1, &cancel);
+        let cancelled = async {
+            received.await.unwrap();
+            cancel.cancel();
+        };
+        let (result, ()) = tokio::join!(query, cancelled);
+        assert_eq!(result.unwrap_err().kind, ErrorKind::Cancelled);
+        let (query, kill) = server.await.unwrap();
+        let target = query.lines().next().unwrap().split_whitespace().nth(1).unwrap();
+        let url = Url::parse(&format!("http://localhost{target}")).unwrap();
+        let query_id = url.query_pairs().find(|(k, _)| k == "query_id").unwrap().1.into_owned();
+        assert!(kill.ends_with(&format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")));
+        assert!(!kill.contains("session_id="));
+    }
+
+    #[tokio::test]
+    async fn unsupported_settings_and_transactions_fail_before_connecting() {
+        for statement in ["BEGIN", "-- comment\n COMMIT", "/* comment */ ROLLBACK", "START TRANSACTION", "SAVEPOINT s"]
+        {
+            assert!(transaction_statement(statement));
+        }
+        assert!(!transaction_statement("SELECT 'BEGIN'"));
+        let sources = [
+            DataSource { options: DbOptions { transaction: DbTxMode::Manual, ..Default::default() }, ..source(1) },
+            DataSource {
+                properties: vec![DbProperty { name: "statement_cache_capacity".into(), value: "4".into() }],
+                ..source(1)
+            },
+            DataSource { properties: vec![DbProperty { name: "password".into(), value: "x".into() }], ..source(1) },
+            DataSource { ssl_ca_file: "unused.pem".into(), ..source(1) },
+            DataSource { ssl: DbSslMode::VerifyCa, ..source(1) },
+            DataSource { ssl: DbSslMode::Require, ssl_cert_file: "unused.pem".into(), ..source(1) },
+        ];
+        for source in sources {
+            let error = match Pool::connect(&source, None, None).await {
+                Ok(_) => panic!("unsupported settings were accepted"),
+                Err(error) => error,
+            };
+            assert_eq!(error.kind, ErrorKind::InvalidInput);
+        }
+    }
+
+    #[tokio::test]
+    #[ignore = "requires CLICKHOUSE_TEST_HOST, CLICKHOUSE_TEST_USER, and CLICKHOUSE_TEST_PASSWORD"]
+    async fn clickhouse_cloud_transport() {
+        let source = DataSource {
+            driver: DbDriver::Clickhouse,
+            host: std::env::var("CLICKHOUSE_TEST_HOST").expect("CLICKHOUSE_TEST_HOST"),
+            port: Some(std::env::var("CLICKHOUSE_TEST_PORT").ok().and_then(|v| v.parse().ok()).unwrap_or(8443)),
+            user: std::env::var("CLICKHOUSE_TEST_USER").expect("CLICKHOUSE_TEST_USER"),
+            ssl: DbSslMode::Require,
+            options: DbOptions {
+                time_zone: "UTC".into(),
+                startup_script: "SET max_threads = 2".into(),
+                ..Default::default()
+            },
+            properties: vec![DbProperty { name: "max_block_size".into(), value: "50".into() }],
+            ..Default::default()
+        };
+        let password = std::env::var("CLICKHOUSE_TEST_PASSWORD").expect("CLICKHOUSE_TEST_PASSWORD");
+        let pool = Pool::connect(&source, Some(&password), None).await.unwrap();
+        let cancel = CancellationToken::new();
+        let settings = pool
+            .execute("SELECT getSetting('max_threads'), getSetting('max_block_size'), timezone()", 1, &cancel)
+            .await
+            .unwrap();
+        assert_eq!(settings.rows, vec![vec![Some("2".into()), Some("50".into()), Some("UTC".into())]]);
+        let result = pool.execute("SELECT toUInt64('18446744073709551615') AS n, CAST(NULL AS Nullable(String)) AS missing, CAST('ᴺᵁᴸᴸ' AS Nullable(String)) AS text, 'a\\nb' AS lines", 1, &cancel).await.unwrap();
+        assert_eq!(
+            result.rows,
+            vec![vec![Some("18446744073709551615".into()), None, Some("ᴺᵁᴸᴸ".into()), Some("a\nb".into())]]
+        );
+        assert_eq!(result.columns[1].type_name, "Nullable(String)");
+        let limited = pool.execute("SELECT number FROM numbers(100)", 2, &cancel).await.unwrap();
+        assert_eq!(limited.rows.len(), 2);
+        assert!(limited.has_more);
+        let marker = format!("transport_cancel_{}", uuid::Uuid::new_v4().simple());
+        let sql = format!("SELECT sleepEachRow(0.05) FROM numbers(50) /* {marker} */");
+        let stop = CancellationToken::new();
+        let query = pool.execute(&sql, 1, &stop);
+        let cancel_query = async {
+            tokio::time::sleep(Duration::from_millis(500)).await;
+            stop.cancel();
+        };
+        let (cancelled, ()) = tokio::join!(query, cancel_query);
+        let cancelled = cancelled.unwrap_err();
+        assert_eq!(cancelled.kind, ErrorKind::Cancelled);
+        assert_eq!(cancelled.message, "cancelled");
+        let active = pool.execute(&format!("SELECT count() FROM system.processes WHERE position(query, '{marker}') > 0 AND query_id != currentQueryID()"), 1, &cancel).await.unwrap();
+        assert_eq!(active.rows, vec![vec![Some("0".into())]]);
+        let table = format!("transport_test_{}", uuid::Uuid::new_v4().simple());
+        pool.execute(&format!("CREATE TEMPORARY TABLE {table} (n UInt8)"), 0, &cancel).await.unwrap();
+        let continuity = async {
+            pool.execute(&format!("INSERT INTO {table} VALUES (7)"), 0, &cancel).await?;
+            pool.execute(&format!("SELECT n FROM {table}"), 1, &cancel).await
+        }
+        .await;
+        let cleanup = pool.execute(&format!("DROP TEMPORARY TABLE {table}"), 0, &cancel).await;
+        assert_eq!(continuity.unwrap().rows, vec![vec![Some("7".into())]]);
+        cleanup.unwrap();
+        pool.close().await;
+        assert!(pool.is_closed());
+    }
+}

crates/ide-db/src/conn.rs

@@ -106,6 +106,7 @@ pub enum Pool {
     Postgres(PgPool),
     Mysql(MySqlPool),
     SqlServer(Bb8Pool<MssqlConnectionManager>),
+    Clickhouse(crate::clickhouse::ClickhousePool),
 }
 
 /// Runs `$body` with `$p` bound to the concrete pool of each driver.
@@ -115,7 +116,7 @@ macro_rules! with_pool {
             Pool::Sqlite($p) => $body,
             Pool::Postgres($p) => $body,
             Pool::Mysql($p) => $body,
-            Pool::SqlServer(_) => unreachable!(),
+            Pool::SqlServer(_) | Pool::Clickhouse(_) => unreachable!(),
         }
     };
 }
@@ -503,6 +504,9 @@ impl Setup {
                 value.parse::<u64>().map_err(|_| IdeError::invalid(format!("{what} must be a whole number: {value}")))
             };
             match (source.driver, name.to_ascii_lowercase().as_str()) {
+                (DbDriver::Clickhouse, "statement_cache_capacity") => {
+                    return Err(IdeError::invalid("ClickHouse HTTP does not support statement caching"));
+                }
                 (_, "statement_cache_capacity") => s.statement_cache = Some(number(&name)? as usize),
                 (_, "connect_timeout") => s.connect_timeout = Some(Duration::from_secs(number(&name)?)),
                 (DbDriver::Postgres, "application_name") => s.application_name = Some(value.to_owned()),
@@ -512,6 +516,9 @@ impl Setup {
                 _ => s.params.push((name, value.to_owned())),
             }
         }
+        if source.driver == DbDriver::Clickhouse && !o.time_zone.trim().is_empty() {
+            s.params.push(("session_timezone".into(), o.time_zone.trim().into()));
+        }
         let script = o.startup_script.trim();
         if !script.is_empty() {
             s.statements.extend(crate::split::split(script, source.driver).into_iter().map(|st| st.text));
@@ -527,6 +534,7 @@ impl Pool {
             Pool::Postgres(_) => DbDriver::Postgres,
             Pool::Mysql(_) => DbDriver::Mysql,
             Pool::SqlServer(_) => DbDriver::SqlServer,
+            Pool::Clickhouse(_) => DbDriver::Clickhouse,
         }
     }
 
@@ -534,6 +542,9 @@ impl Pool {
     pub async fn connect(source: &DataSource, password: Option<&str>, root: Option<&Path>) -> IdeResult<Self> {
         const MAX: u32 = 4;
         let setup = Setup::of(source)?;
+        if source.driver == DbDriver::Clickhouse {
+            return crate::clickhouse::ClickhousePool::connect(source, password, setup).await.map(Pool::Clickhouse);
+        }
         let timeout = setup.connect_timeout.unwrap_or(Duration::from_secs(30));
         let init = Arc::new(setup.statements);
         // Runs the session statements (startup script…) on every new connection.
@@ -695,12 +706,14 @@ impl Pool {
                 conn.query("SELECT 1", &[]).await.map_err(mssql_err)?.into_results().await.map_err(mssql_err)?;
                 Ok(Pool::SqlServer(pool))
             }
+            DbDriver::Clickhouse => unreachable!(),
         }
     }
 
     pub async fn close(&self) {
         match self {
             Pool::SqlServer(_) => {}
+            Pool::Clickhouse(p) => p.close(),
             _ => with_pool!(self, p => p.close().await),
         }
     }
@@ -708,12 +721,16 @@ impl Pool {
     pub fn is_closed(&self) -> bool {
         match self {
             Pool::SqlServer(_) => false,
+            Pool::Clickhouse(p) => p.is_closed(),
             _ => with_pool!(self, p => p.is_closed()),
         }
     }
 
     /// Runs `sql` (no row limit beyond `max`), for introspection: cells are text (see [`Cells::Text`]).
     pub async fn rows(&self, sql: &str, max: usize) -> IdeResult<Vec<Vec<Option<String>>>> {
+        if let Pool::Clickhouse(p) = self {
+            return Ok(p.execute(sql, max, &CancellationToken::new()).await?.rows);
+        }
         let fetched: IdeResult<Fetched> = match self {
             Pool::SqlServer(p) => {
                 let mut conn = p.get_owned().await.map_err(mssql_pool_err)?;
@@ -727,6 +744,9 @@ 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> {
+        if let Pool::Clickhouse(p) = self {
+            return p.execute(sql, max_rows, cancel).await;
+        }
         let mut conn = Held::acquire(self).await?;
         let r = conn.execute(self, sql, max_rows, cancel).await;
         if cancel.is_cancelled() {
@@ -740,6 +760,7 @@ impl Pool {
     /// row when flagged (table editor submits).
     pub async fn transaction(&self, statements: &[(String, bool)]) -> IdeResult<u64> {
         match self {
+            Pool::Clickhouse(_) => Err(crate::clickhouse::transaction_error()),
             Pool::SqlServer(p) => {
                 let mut conn = p.get_owned().await.map_err(mssql_pool_err)?;
                 let result = async {
@@ -790,6 +811,7 @@ pub enum Held {
     Postgres(PoolConnection<Postgres>),
     Mysql(PoolConnection<MySql>),
     SqlServer(Box<bb8::PooledConnection<'static, MssqlConnectionManager>>),
+    Clickhouse(crate::clickhouse::ClickhousePool),
 }
 
 impl Held {
@@ -799,6 +821,12 @@ impl Held {
             Pool::Postgres(p) => Held::Postgres(p.acquire().await.map_err(db_err)?),
             Pool::Mysql(p) => Held::Mysql(p.acquire().await.map_err(db_err)?),
             Pool::SqlServer(p) => Held::SqlServer(Box::new(p.get_owned().await.map_err(mssql_pool_err)?)),
+            Pool::Clickhouse(p) => {
+                if p.is_closed() {
+                    return Err(IdeError::new(ErrorKind::Io, "ClickHouse connection is closed"));
+                }
+                Held::Clickhouse(p.clone())
+            }
         })
     }
 
@@ -806,13 +834,14 @@ impl Held {
     pub async fn command(&mut self, sql: &str) -> IdeResult<()> {
         match self {
             Held::SqlServer(c) => mssql_command(c, sql).await,
+            Held::Clickhouse(_) => Err(crate::clickhouse::transaction_error()),
             other => {
                 let sql = sqlx::AssertSqlSafe(sql.to_owned());
                 match other {
                     Held::Sqlite(c) => sqlx::raw_sql(sql).execute(&mut **c).await.map(drop),
                     Held::Postgres(c) => sqlx::raw_sql(sql).execute(&mut **c).await.map(drop),
                     Held::Mysql(c) => sqlx::raw_sql(sql).execute(&mut **c).await.map(drop),
-                    Held::SqlServer(_) => unreachable!(),
+                    Held::SqlServer(_) | Held::Clickhouse(_) => unreachable!(),
                 }
                 .map_err(db_err)
             }
@@ -833,6 +862,7 @@ impl Held {
             Held::SqlServer(mut c) => {
                 c.0.take();
             }
+            Held::Clickhouse(_) => {}
         }
     }
 
@@ -845,6 +875,9 @@ impl Held {
         max_rows: usize,
         cancel: &CancellationToken,
     ) -> IdeResult<QueryResult> {
+        if let Held::Clickhouse(c) = self {
+            return c.execute(sql, max_rows, cancel).await;
+        }
         let started = Instant::now();
         // `$id`: the query naming the server process, `$kill`: how another connection stops it.
         macro_rules! run {
@@ -887,6 +920,7 @@ impl Held {
                     () = cancel.cancelled() => return Err(IdeError::cancelled()),
                 }
             }
+            Held::Clickhouse(_) => unreachable!(),
         };
         let (columns, rows, affected, has_more, first) = fetched;
         let elapsed_ms = started.elapsed().as_secs_f64() * 1000.0;
@@ -907,7 +941,7 @@ pub fn begin_statement(driver: DbDriver) -> &'static str {
     match driver {
         DbDriver::Mysql => "START TRANSACTION",
         DbDriver::SqlServer => "BEGIN TRAN",
-        DbDriver::Sqlite | DbDriver::Postgres => "BEGIN",
+        DbDriver::Sqlite | DbDriver::Postgres | DbDriver::Clickhouse => "BEGIN",
     }
 }
 

crates/ide-db/src/lib.rs

@@ -2,6 +2,7 @@
 //! execution ([`conn`]), introspection, table data paging / editing ([`sql`])
 //! and statement splitting ([`split`]), for SQLite, PostgreSQL and MySQL/MariaDB.
 
+mod clickhouse;
 pub mod conn;
 pub mod history;
 pub mod plan;
@@ -547,12 +548,14 @@ impl DbManager {
         })?;
         let version = match source.driver {
             DbDriver::Sqlite => "SELECT 'SQLite ' || sqlite_version()",
-            DbDriver::Postgres => "SELECT version()",
+            DbDriver::Postgres | DbDriver::Clickhouse => "SELECT version()",
             DbDriver::Mysql => "SELECT CONCAT(@@version_comment, ' ', VERSION())",
             DbDriver::SqlServer => "SELECT @@VERSION",
         };
-        let v = pool.rows(version, 1).await.ok().and_then(|r| r.into_iter().next()?.into_iter().next()?);
+        let result = pool.rows(version, 1).await;
         pool.close().await;
+        let rows = if source.driver == DbDriver::Clickhouse { result? } else { result.unwrap_or_default() };
+        let v = rows.into_iter().next().and_then(|r| r.into_iter().next().flatten());
         Ok(v.unwrap_or_else(|| "Connected".into()))
     }
 
@@ -701,8 +704,11 @@ impl DbManager {
                 _ => indexes.push(IndexInfo { name, unique: flag(&unique), columns: vec![col] }),
             }
         }
-        let fk_rows =
-            pool.rows(&sql::table_foreign_keys(driver, schema, table), MAX_META_ROWS).await.unwrap_or_default();
+        let fk_rows = if driver == DbDriver::Clickhouse {
+            Vec::new()
+        } else {
+            pool.rows(&sql::table_foreign_keys(driver, schema, table), MAX_META_ROWS).await.unwrap_or_default()
+        };
         let mut foreign_keys = group_foreign_keys(fk_rows, &[]);
         // SQLite keys that reference the primary key implicitly: look it up.
         for k in foreign_keys.iter_mut().filter(|k| k.ref_columns.is_empty()) {
@@ -715,13 +721,15 @@ impl DbManager {
                 .collect();
         }
         foreign_keys.retain(|k| k.columns.len() == k.ref_columns.len());
-        let triggers = pool
-            .rows(&sql::triggers(driver, schema, table), MAX_META_ROWS)
-            .await
-            .unwrap_or_else(|e| {
+        let trigger_rows = if driver == DbDriver::Clickhouse {
+            Vec::new()
+        } else {
+            pool.rows(&sql::triggers(driver, schema, table), MAX_META_ROWS).await.unwrap_or_else(|e| {
                 tracing::warn!("triggers: {}", e.message);
                 Vec::new()
             })
+        };
+        let triggers = trigger_rows
             .into_iter()
             .filter_map(|r| {
                 let mut it = r.into_iter();
@@ -822,6 +830,11 @@ impl DbManager {
                 let ddl = cells(pool.rows(&q, 1).await?, 1).into_iter().next();
                 ddl.map(|d| format!("{d};\n")).ok_or_else(missing)
             }
+            DbDriver::Clickhouse => {
+                let q = format!("SHOW CREATE TABLE {}", sql::qualified(driver, schema, name));
+                let ddl = cells(pool.rows(&q, 1).await?, 0).into_iter().next();
+                ddl.map(|d| format!("{};\n", d.trim_end().trim_end_matches(';'))).ok_or_else(missing)
+            }
             DbDriver::SqlServer => {
                 let obj = format!("{}.{}", schema, name).replace('\'', "''");
                 let ddl = cells(pool.rows(&format!("SELECT OBJECT_DEFINITION(OBJECT_ID('{}'))", obj), 1).await?, 0)
@@ -902,10 +915,14 @@ impl DbManager {
             }
         }
         // Foreign keys are a nicety (JOIN completion): a server that refuses the catalog query still completes.
-        let fk_rows = pool.rows(sql::foreign_keys(driver), MAX_META_ROWS).await.unwrap_or_else(|e| {
-            tracing::warn!("foreign keys: {}", e.message);
+        let fk_rows = if driver == DbDriver::Clickhouse {
             Vec::new()
-        });
+        } else {
+            pool.rows(sql::foreign_keys(driver), MAX_META_ROWS).await.unwrap_or_else(|e| {
+                tracing::warn!("foreign keys: {}", e.message);
+                Vec::new()
+            })
+        };
         let foreign_keys = group_foreign_keys(fk_rows, &tables);
         let default_schema = match sql::current_schema(driver) {
             None => "main".to_owned(),
@@ -980,6 +997,9 @@ impl DbManager {
         let Some(session) = session else {
             return pool.execute(statement, max_rows, cancel).await;
         };
+        if pool.driver() == DbDriver::Clickhouse {
+            return Err(IdeError::invalid("ClickHouse manual transactions are unsupported"));
+        }
         let mut held = session.lock().await;
         if held.is_none() {
             let mut conn = Held::acquire(&pool).await?;
@@ -998,8 +1018,11 @@ impl DbManager {
 
     /// Switches `id` between auto-commit and manual commit. Leaving manual
     /// mode rolls back what was not committed.
-    pub async fn set_manual_commit(&self, id: &str, manual: bool) {
+    pub async fn set_manual_commit(&self, id: &str, manual: bool) -> IdeResult<()> {
         if manual {
+            if self.source(id)?.driver == DbDriver::Clickhouse {
+                return Err(IdeError::invalid("ClickHouse manual transactions are unsupported"));
+            }
             self.sessions.lock().entry(id.to_owned()).or_default();
         } else {
             let session = self.sessions.lock().remove(id);
@@ -1007,10 +1030,14 @@ impl DbManager {
                 end_session(&s).await;
             }
         }
+        Ok(())
     }
 
     /// Commits (or rolls back) the open transaction of a manual-commit data source.
     pub async fn finish_transaction(&self, id: &str, commit: bool) -> IdeResult<()> {
+        if self.source(id).is_ok_and(|s| s.driver == DbDriver::Clickhouse) {
+            return Err(IdeError::invalid("ClickHouse manual transactions are unsupported"));
+        }
         let session = self.sessions.lock().get(id).cloned();
         let Some(session) = session else { return Ok(()) };
         let mut held = session.lock().await;
@@ -1052,6 +1079,9 @@ impl DbManager {
 
     /// Applies the table editor's pending changes in one transaction.
     pub async fn apply_edits(&self, id: &str, schema: &str, table: &str, edits: &[DbRowEdit]) -> IdeResult<u64> {
+        if self.source(id)?.driver == DbDriver::Clickhouse {
+            return Err(IdeError::invalid("ClickHouse table editing is unsupported"));
+        }
         let pool = self.pool(id).await?;
         let driver = pool.driver();
         let statements = edits
@@ -1064,3 +1094,37 @@ impl DbManager {
         pool.transaction(&statements).await
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn clickhouse_rejects_manual_transactions_and_table_edits_without_connecting() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path().to_path_buf();
+        let ssh = Arc::new(SshManager::new(root.join("ssh-passwords.json")));
+        let db = DbManager::new(root.clone(), root.join("passwords.json"), root.join("history.json"), ssh);
+        db.save_sources(vec![DataSource {
+            id: "clickhouse".into(),
+            name: "clickhouse".into(),
+            driver: DbDriver::Clickhouse,
+            host: "127.0.0.1".into(),
+            port: Some(1),
+            ..Default::default()
+        }])
+        .await
+        .unwrap();
+        let error = db.set_manual_commit("clickhouse", true).await.unwrap_err();
+        assert!(error.message.contains("manual transactions are unsupported"));
+        assert!(db.sessions.lock().is_empty());
+        for commit in [false, true] {
+            let error = db.finish_transaction("clickhouse", commit).await.unwrap_err();
+            assert!(error.message.contains("manual transactions are unsupported"));
+        }
+        let error = db.apply_edits("clickhouse", "default", "events", &[]).await.unwrap_err();
+        assert!(error.message.contains("table editing is unsupported"));
+        assert!(!db.is_connected("clickhouse"));
+        db.set_manual_commit("clickhouse", false).await.unwrap();
+    }
+}

crates/ide-db/src/plan.rs

@@ -35,6 +35,7 @@ pub fn explain_statement(driver: DbDriver, statement: &str) -> String {
     match driver {
         DbDriver::Sqlite => format!("EXPLAIN QUERY PLAN {s}"),
         DbDriver::Postgres => format!("EXPLAIN (FORMAT JSON) {s}"),
+        DbDriver::Clickhouse => format!("EXPLAIN json = 1 {s}"),
         DbDriver::Mysql => format!("EXPLAIN {s}"),
         DbDriver::SqlServer => format!("SET SHOWPLAN_TEXT ON; {s}"),
     }
@@ -44,7 +45,7 @@ pub fn explain_statement(driver: DbDriver, statement: &str) -> String {
 pub fn parse(driver: DbDriver, result: &QueryResult) -> IdeResult<Vec<PlanNode>> {
     match driver {
         DbDriver::Sqlite => Ok(sqlite(&result.rows)),
-        DbDriver::Postgres => {
+        DbDriver::Postgres | DbDriver::Clickhouse => {
             let text: String =
                 result.rows.iter().filter_map(|r| r.first().cloned().flatten()).collect::<Vec<_>>().join("\n");
             let json: Value = serde_json::from_str(&text).map_err(|e| IdeError::invalid(format!("plan: {e}")))?;
@@ -199,6 +200,7 @@ mod tests {
         assert_eq!(explain_statement(DbDriver::Sqlite, "select 1;"), "EXPLAIN QUERY PLAN select 1");
         assert_eq!(explain_statement(DbDriver::Postgres, " select 1 "), "EXPLAIN (FORMAT JSON) select 1");
         assert_eq!(explain_statement(DbDriver::Mysql, "select 1"), "EXPLAIN select 1");
+        assert_eq!(explain_statement(DbDriver::Clickhouse, " select 1;"), "EXPLAIN json = 1 select 1");
         assert_eq!(explain_statement(DbDriver::SqlServer, "select 1"), "SET SHOWPLAN_TEXT ON; select 1");
     }
 
@@ -254,6 +256,21 @@ mod tests {
         assert_eq!((plan[3].parent, plan[3].operation.as_str()), (Some(2), "Seq Scan"));
     }
 
+    #[test]
+    fn reads_clickhouse_json_plans_and_rejects_invalid_json() {
+        let json = r#"[{"Plan": {"Node Type": "Expression", "Node Id": "Expression_5",
+            "Description": "Project names", "Plans": [
+                {"Node Type": "ReadFromMergeTree", "Node Id": "ReadFromMergeTree_0",
+                 "Description": "default.events"}
+            ]}}]"#;
+        let plan = parse(DbDriver::Clickhouse, &result(&["explain"], vec![vec![Some(json)]])).unwrap();
+        assert_eq!(plan.len(), 2);
+        assert_eq!((plan[0].parent, plan[0].operation.as_str()), (None, "Expression"));
+        assert_eq!((plan[1].parent, plan[1].operation.as_str()), (Some(0), "ReadFromMergeTree"));
+        assert!(plan[1].properties.iter().any(|p| p.name == "Description" && p.value == "default.events"));
+        assert!(parse(DbDriver::Clickhouse, &result(&["explain"], vec![vec![Some("invalid")]])).is_err());
+    }
+
     #[test]
     fn reads_mysql_rows() {
         let r = result(

crates/ide-db/src/source.rs

@@ -18,6 +18,7 @@ pub enum DbDriver {
     Mysql,
     /// Microsoft SQL Server.
     SqlServer,
+    Clickhouse,
 }
 
 impl DbDriver {
@@ -27,6 +28,7 @@ impl DbDriver {
             DbDriver::Postgres => Some(5432),
             DbDriver::Mysql => Some(3306),
             DbDriver::SqlServer => Some(1433),
+            DbDriver::Clickhouse => Some(8123),
         }
     }
 }
@@ -253,6 +255,7 @@ pub fn scheme_driver(scheme: &str) -> Option<DbDriver> {
         "mysql" | "mariadb" | "tidb" | "singlestore" | "memsql" | "oceanbase" => Some(DbDriver::Mysql),
         "sqlserver" | "mssql" | "mssqlserver" => Some(DbDriver::SqlServer),
         "sqlite" | "sqlite3" => Some(DbDriver::Sqlite),
+        "clickhouse" | "http" | "https" => Some(DbDriver::Clickhouse),
         _ => None,
     }
 }
@@ -260,7 +263,7 @@ pub fn scheme_driver(scheme: &str) -> Option<DbDriver> {
 /// Parses `scheme://[user[:password]@]host[:port][/database][?k=v&…]`, `jdbc:` forms
 /// included, and `sqlite:path`.
 pub fn parse_url(raw: &str) -> IdeResult<ParsedUrl> {
-    let bad = || IdeError::invalid(format!("not a database URL: {raw}"));
+    let bad = || IdeError::invalid("invalid database URL");
     let url = raw.trim();
     let url = url.strip_prefix("jdbc:").or_else(|| url.strip_prefix("JDBC:")).unwrap_or(url);
     let (scheme, rest) = url.split_once(':').ok_or_else(bad)?;
@@ -367,6 +370,15 @@ impl DataSource {
         }
         properties.append(&mut s.properties);
         s.properties = properties;
+        if s.driver == DbDriver::Clickhouse {
+            let raw_url = self.url.trim().to_ascii_lowercase();
+            let url = raw_url.strip_prefix("jdbc:").unwrap_or(&raw_url);
+            if url.starts_with("https://") {
+                s.ssl = DbSslMode::VerifyFull;
+            } else if url.starts_with("http://") {
+                s.ssl = DbSslMode::Disable;
+            }
+        }
         Ok(s)
     }
 
@@ -519,4 +531,31 @@ mod tests {
         assert!(DataSource { url: "mysql://h/db".into(), ..s.clone() }.resolved().is_err());
         assert_eq!(DataSource { url_only: false, ..s }.resolved().unwrap().host, "localhost");
     }
+
+    #[test]
+    fn clickhouse_urls_resolve_http_https_and_credentials() {
+        assert_eq!(DbDriver::Clickhouse.default_port(), Some(8123));
+        let source = DataSource {
+            driver: DbDriver::Clickhouse,
+            url_only: true,
+            url: "https://reader:s%[email protected]:8443/analytics?max_execution_time=30".into(),
+            ..Default::default()
+        };
+        let resolved = source.resolved().unwrap();
+        assert_eq!(resolved.host, "db.example");
+        assert_eq!(resolved.port, Some(8443));
+        assert_eq!(resolved.database, "analytics");
+        assert_eq!(resolved.user, "reader");
+        assert_eq!(resolved.ssl, DbSslMode::VerifyFull);
+        assert_eq!(source.url_password().as_deref(), Some("s@cret"));
+        assert_eq!(resolved.properties[0].name, "max_execution_time");
+        let http = DataSource { url: "http://localhost/default".into(), ..source.clone() }.resolved().unwrap();
+        assert_eq!(http.ssl, DbSslMode::Disable);
+        let jdbc = DataSource { url: "jdbc:clickhouse://localhost/analytics".into(), ..source.clone() };
+        assert_eq!(jdbc.resolved().unwrap().database, "analytics");
+        let secure = DataSource { url: "https://db.example/default?sslmode=disable".into(), ..source };
+        assert_eq!(secure.resolved().unwrap().ssl, DbSslMode::VerifyFull);
+        let error = parse_url("clickhouse://reader:[email protected]:invalid/default").unwrap_err();
+        assert!(!error.message.contains("secret"));
+    }
 }

crates/ide-db/src/split.rs

@@ -28,6 +28,7 @@ enum State {
 /// Every statement of `text` that contains more than whitespace and comments.
 pub fn split(text: &str, driver: DbDriver) -> Vec<SqlStatement> {
     let mysql = driver == DbDriver::Mysql;
+    let clickhouse = driver == DbDriver::Clickhouse;
     let chars: Vec<(usize, char)> = text.char_indices().collect();
     // UTF-16 offset of each char index (plus the end).
     let mut u16_at = Vec::with_capacity(chars.len() + 1);
@@ -81,7 +82,7 @@ pub fn split(text: &str, driver: DbDriver) -> Vec<SqlStatement> {
                     state = State::Double;
                     has_code = true;
                 }
-                '`' if mysql => {
+                '`' if mysql || clickhouse => {
                     state = State::Backtick;
                     has_code = true;
                 }
@@ -117,7 +118,7 @@ pub fn split(text: &str, driver: DbDriver) -> Vec<SqlStatement> {
                 _ => {}
             },
             State::Single => {
-                if mysql && c == '\\' {
+                if (mysql || clickhouse) && c == '\\' {
                     i += 1;
                 } else if c == '\'' {
                     if next == Some('\'') {
@@ -128,7 +129,9 @@ pub fn split(text: &str, driver: DbDriver) -> Vec<SqlStatement> {
                 }
             }
             State::Double => {
-                if c == '"' {
+                if clickhouse && c == '\\' {
+                    i += 1;
+                } else if c == '"' {
                     if next == Some('"') {
                         i += 1;
                     } else {
@@ -137,7 +140,9 @@ pub fn split(text: &str, driver: DbDriver) -> Vec<SqlStatement> {
                 }
             }
             State::Backtick => {
-                if c == '`' {
+                if clickhouse && (c == '\\' || (c == '`' && next == Some('`'))) {
+                    i += 1;
+                } else if c == '`' {
                     state = State::Code;
                 }
             }
@@ -224,6 +229,12 @@ mod tests {
         assert_eq!(texts(sql, DbDriver::Mysql), vec!["select `a;b`, 'it\\'s;' from t # x;y", "select 2"]);
     }
 
+    #[test]
+    fn clickhouse_backticks_and_escaped_quotes_keep_statements_intact() {
+        let query = r#"SELECT `a\`;b`, "c\";d", 'it\'s;safe'; SELECT 2"#;
+        assert_eq!(texts(query, DbDriver::Clickhouse), vec![r#"SELECT `a\`;b`, "c\";d", 'it\'s;safe'"#, "SELECT 2"]);
+    }
+
     #[test]
     fn postgres_dollar_quotes() {
         let sql =

crates/ide-db/src/sql.rs

@@ -7,6 +7,7 @@ use specta::Type;
 
 pub fn quote_ident(driver: DbDriver, name: &str) -> String {
     match driver {
+        DbDriver::Clickhouse => format!("`{}`", name.replace('\\', "\\\\").replace('`', "\\`")),
         DbDriver::Mysql => format!("`{}`", name.replace('`', "``")),
         DbDriver::SqlServer => format!("[{}]", name.replace(']', "]]")),
         _ => format!("\"{}\"", name.replace('"', "\"\"")),
@@ -15,7 +16,7 @@ pub fn quote_ident(driver: DbDriver, name: &str) -> String {
 
 pub fn quote_literal(driver: DbDriver, value: &str) -> String {
     let mut s = value.replace('\'', "''");
-    if driver == DbDriver::Mysql {
+    if matches!(driver, DbDriver::Mysql | DbDriver::Clickhouse) {
         s = s.replace('\\', "\\\\");
     }
     format!("'{s}'")
@@ -48,6 +49,10 @@ pub const INTERNAL_DATABASES: &[&str] = &["rdsadmin", "azure_maintenance", "azur
 pub fn schemas(driver: DbDriver, system: bool) -> &'static str {
     match driver {
         DbDriver::Sqlite => "SELECT name FROM pragma_database_list WHERE name <> 'temp' ORDER BY seq",
+        DbDriver::Clickhouse if system => "SELECT name FROM system.databases ORDER BY name",
+        DbDriver::Clickhouse => {
+            "SELECT name FROM system.databases WHERE lower(name) NOT IN ('system', 'information_schema') ORDER BY name"
+        }
         DbDriver::Postgres if system => {
             "SELECT schema_name FROM information_schema.schemata \
              WHERE schema_name NOT LIKE 'pg\\_toast%' AND schema_name NOT LIKE 'pg\\_temp%' ORDER BY 1"
@@ -73,6 +78,12 @@ pub fn schemas(driver: DbDriver, system: bool) -> &'static str {
 /// Rows: `name, kind` where kind is `table`, `view` or `materialized view`.
 pub fn tables(driver: DbDriver, schema: &str) -> String {
     match driver {
+        DbDriver::Clickhouse => format!(
+            "SELECT name, CASE engine WHEN 'View' THEN 'view' WHEN 'MaterializedView' THEN 'materialized view' \
+             WHEN 'WindowView' THEN 'view' ELSE 'table' END FROM system.tables \
+             WHERE database = {} AND is_temporary = 0 ORDER BY name",
+            quote_literal(driver, schema)
+        ),
         DbDriver::Sqlite => format!(
             "SELECT name, type FROM {}.sqlite_master WHERE type IN ('table', 'view') \
              AND name NOT LIKE 'sqlite\\_%' ESCAPE '\\' ORDER BY name",
@@ -101,6 +112,12 @@ pub fn tables(driver: DbDriver, schema: &str) -> String {
 pub fn columns(driver: DbDriver, schema: &str, table: &str) -> String {
     let (s, t) = (quote_literal(driver, schema), quote_literal(driver, table));
     match driver {
+        DbDriver::Clickhouse => format!(
+            "SELECT name, type, CASE WHEN startsWith(type, 'Nullable(') \
+             OR startsWith(type, 'LowCardinality(Nullable(') THEN 'YES' ELSE 'NO' END, \
+             if(default_kind = '', NULL, default_expression), is_in_primary_key \
+             FROM system.columns WHERE database = {s} AND table = {t} ORDER BY position"
+        ),
         DbDriver::Sqlite => format!(
             "SELECT name, type, CASE WHEN \"notnull\" = 0 THEN 'YES' ELSE 'NO' END, dflt_value, \
              CASE WHEN pk > 0 THEN 1 ELSE 0 END FROM pragma_table_info({t}, {s}) ORDER BY cid"
@@ -138,6 +155,12 @@ pub fn columns(driver: DbDriver, schema: &str, table: &str) -> String {
 pub fn indexes(driver: DbDriver, schema: &str, table: &str) -> String {
     let (s, t) = (quote_literal(driver, schema), quote_literal(driver, table));
     match driver {
+        DbDriver::Clickhouse => format!(
+            "SELECT * FROM (SELECT 'PRIMARY KEY' AS index_name, 0 AS is_unique, primary_key AS expression \
+             FROM system.tables WHERE database = {s} AND name = {t} AND primary_key != '' \
+             UNION ALL SELECT name, 0, expr FROM system.data_skipping_indices \
+             WHERE database = {s} AND table = {t}) ORDER BY index_name"
+        ),
         DbDriver::Sqlite => format!(
             "SELECT il.name, il.\"unique\", ii.name FROM pragma_index_list({t}, {s}) il \
              JOIN pragma_index_info(il.name, {s}) ii ORDER BY il.name, ii.seqno"
@@ -169,6 +192,15 @@ pub fn indexes(driver: DbDriver, schema: &str, table: &str) -> String {
 /// for SQL completion, grouped by table in column order.
 pub fn completion_columns(driver: DbDriver) -> &'static str {
     match driver {
+        DbDriver::Clickhouse => {
+            "SELECT c.database, c.table, CASE t.engine WHEN 'View' THEN 'view' \
+             WHEN 'MaterializedView' THEN 'materialized view' WHEN 'WindowView' THEN 'view' ELSE 'table' END, \
+             c.name, c.type, CASE WHEN startsWith(c.type, 'Nullable(') \
+             OR startsWith(c.type, 'LowCardinality(Nullable(') THEN 'YES' ELSE 'NO' END, c.is_in_primary_key, 1 \
+             FROM system.columns c JOIN system.tables t ON t.database = c.database AND t.name = c.table \
+             WHERE lower(c.database) NOT IN ('system', 'information_schema') AND t.is_temporary = 0 \
+             ORDER BY c.database, c.table, c.position LIMIT 50000"
+        }
         DbDriver::Sqlite => {
             "SELECT 'main', m.name, m.type, p.name, p.type, CASE WHEN p.\"notnull\" = 0 THEN 'YES' ELSE 'NO' END, \
              CASE WHEN p.pk > 0 THEN 1 ELSE 0 END, \
@@ -221,6 +253,7 @@ pub fn completion_columns(driver: DbDriver) -> &'static str {
 /// when the key references the primary key implicitly.
 pub fn foreign_keys(driver: DbDriver) -> &'static str {
     match driver {
+        DbDriver::Clickhouse => "SELECT '', '', '', '', '', '', '' WHERE 0",
         DbDriver::Sqlite => {
             "SELECT 'main', m.name, f.id, f.\"from\", 'main', f.\"table\", f.\"to\" \
              FROM sqlite_master m JOIN pragma_foreign_key_list(m.name) f \
@@ -258,6 +291,7 @@ pub fn foreign_keys(driver: DbDriver) -> &'static str {
 pub fn table_foreign_keys(driver: DbDriver, schema: &str, table: &str) -> String {
     let (s, t) = (quote_literal(driver, schema), quote_literal(driver, table));
     match driver {
+        DbDriver::Clickhouse => foreign_keys(driver).to_owned(),
         DbDriver::Sqlite => format!(
             "SELECT {s}, {t}, f.id, f.\"from\", {s}, f.\"table\", f.\"to\"              FROM pragma_foreign_key_list({t}, {s}) f ORDER BY f.id, f.seq"
         ),
@@ -276,6 +310,7 @@ pub fn table_foreign_keys(driver: DbDriver, schema: &str, table: &str) -> String
 /// The schema unqualified names resolve to (`None`: always `main`).
 pub fn current_schema(driver: DbDriver) -> Option<&'static str> {
     match driver {
+        DbDriver::Clickhouse => Some("SELECT currentDatabase()"),
         DbDriver::Sqlite => None,
         DbDriver::Postgres => Some("SELECT current_schema()"),
         DbDriver::Mysql => Some("SELECT DATABASE()"),
@@ -362,6 +397,9 @@ fn where_key(driver: DbDriver, key: &[CellValue]) -> String {
 /// The DML statement for `edit`. Values are written as quoted literals, which
 /// every supported database coerces to the column type.
 pub fn edit_statement(driver: DbDriver, schema: &str, table: &str, edit: &DbRowEdit) -> Result<String, String> {
+    if driver == DbDriver::Clickhouse {
+        return Err("ClickHouse table editing is unsupported: primary keys do not uniquely identify rows and edits require transactions".into());
+    }
     let target = qualified(driver, schema, table);
     match edit {
         DbRowEdit::Update { key, values } => {
@@ -450,6 +488,7 @@ pub fn postgres_ddl_indexes(oid: u32) -> String {
 pub fn triggers(driver: DbDriver, schema: &str, table: &str) -> String {
     let (s, t) = (quote_literal(driver, schema), quote_literal(driver, table));
     match driver {
+        DbDriver::Clickhouse => "SELECT '', '', '' WHERE 0".to_owned(),
         DbDriver::Sqlite => format!(
             "SELECT name, sql FROM {}.sqlite_master WHERE type = 'trigger' AND tbl_name = {t} ORDER BY name",
             quote_ident(driver, schema)
@@ -492,7 +531,7 @@ pub fn sqlite_trigger_event(sql: &str) -> (String, String) {
 pub fn routines(driver: DbDriver, schema: &str) -> Option<String> {
     let s = quote_literal(driver, schema);
     match driver {
-        DbDriver::Sqlite => None,
+        DbDriver::Sqlite | DbDriver::Clickhouse => None,
         // Functions of extensions are left out, as in IDEA.
         DbDriver::Postgres => Some(format!(
             "SELECT p.proname, CASE WHEN p.prokind = 'p' THEN 'procedure' ELSE 'function' END, \
@@ -625,6 +664,71 @@ mod tests {
         assert_eq!(quote_literal(DbDriver::Mysql, "it's \\"), "'it''s \\\\'");
     }
 
+    #[test]
+    fn clickhouse_escapes_backslashes_and_delimiters() {
+        let driver = DbDriver::Clickhouse;
+        assert_eq!(quote_literal(driver, r"path\O'Brien"), r"'path\\O''Brien'");
+        assert_eq!(quote_literal(driver, r"\' OR 1 = 1 --"), r"'\\'' OR 1 = 1 --'");
+        assert_eq!(quote_ident(driver, r"a\`b"), r"`a\\\`b`");
+        assert_eq!(qualified(driver, "data base", "event`log"), r"`data base`.`event\`log`");
+    }
+
+    #[test]
+    fn clickhouse_metadata_preserves_types_defaults_and_nonunique_keys() {
+        let driver = DbDriver::Clickhouse;
+        assert_eq!(schemas(driver, true), "SELECT name FROM system.databases ORDER BY name");
+        assert!(schemas(driver, false).contains("lower(name) NOT IN ('system', 'information_schema')"));
+        assert_eq!(current_schema(driver), Some("SELECT currentDatabase()"));
+        let relations = tables(driver, "event's\\db");
+        assert!(relations.contains("WHEN 'MaterializedView' THEN 'materialized view'"));
+        assert!(relations.contains(r"WHERE database = 'event''s\\db' AND is_temporary = 0"));
+        let fields = columns(driver, "default", "events");
+        assert!(fields.starts_with("SELECT name, type, CASE WHEN startsWith(type, 'Nullable(')"));
+        assert!(fields.contains("startsWith(type, 'LowCardinality(Nullable(')"));
+        assert!(fields.contains("if(default_kind = '', NULL, default_expression), is_in_primary_key"));
+        assert!(fields.ends_with("WHERE database = 'default' AND table = 'events' ORDER BY position"));
+        let keys = indexes(driver, "default", "events");
+        assert!(keys.contains("'PRIMARY KEY' AS index_name, 0 AS is_unique, primary_key AS expression"));
+        assert!(keys.contains("SELECT name, 0, expr FROM system.data_skipping_indices"));
+        let completion = completion_columns(driver);
+        assert!(completion.contains("c.is_in_primary_key, 1"));
+        assert!(completion.contains("ORDER BY c.database, c.table, c.position LIMIT 50000"));
+    }
+
+    #[test]
+    fn clickhouse_has_no_foreign_key_trigger_or_schema_routine_catalogs() {
+        let driver = DbDriver::Clickhouse;
+        assert_eq!(foreign_keys(driver), "SELECT '', '', '', '', '', '', '' WHERE 0");
+        assert_eq!(table_foreign_keys(driver, "default", "events"), foreign_keys(driver));
+        assert_eq!(triggers(driver, "default", "events"), "SELECT '', '', '' WHERE 0");
+        assert!(routines(driver, "default").is_none());
+        assert!(sequences(driver, "default").is_none());
+        assert!(object_ddl(driver, "default", crate::DbObjectKind::Trigger, "t").is_none());
+    }
+
+    #[test]
+    fn clickhouse_pages_quote_keys_and_fetch_one_extra_row() {
+        let sort = [SortKey { column: "event`id".into(), descending: true }];
+        assert_eq!(
+            table_page(DbDriver::Clickhouse, "default", "events", Some("WHERE id > 3"), &sort, 50, 25),
+            r"SELECT * FROM `default`.`events` WHERE id > 3 ORDER BY `event\`id` DESC LIMIT 26 OFFSET 50"
+        );
+    }
+
+    #[test]
+    fn clickhouse_keys_never_enable_transactional_table_edits() {
+        let key = vec![cv("id", Some("1"))];
+        for edit in [
+            DbRowEdit::Update { key: key.clone(), values: vec![cv("name", Some("new"))] },
+            DbRowEdit::Delete { key },
+            DbRowEdit::Insert { values: vec![cv("name", Some("new"))] },
+            DbRowEdit::Insert { values: vec![] },
+        ] {
+            let error = edit_statement(DbDriver::Clickhouse, "default", "events", &edit).unwrap_err();
+            assert!(error.contains("primary keys do not uniquely identify rows"));
+        }
+    }
+
     #[test]
     fn pages() {
         let sort = [SortKey { column: "id".into(), descending: true }];

crates/ide-db/tests/clickhouse.rs

@@ -0,0 +1,136 @@
+use ide_core::{CancellationToken, IdeError, IdeResult};
+use ide_db::{CellValue, DataSource, DbDriver, DbManager, DbRowEdit, DbSslMode, SortKey, sql};
+use std::sync::Arc;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+fn check(condition: bool, message: &str) -> IdeResult<()> {
+    if condition { Ok(()) } else { Err(IdeError::invalid(message)) }
+}
+
+#[tokio::test]
+#[ignore = "requires CLICKHOUSE_TEST_HOST, CLICKHOUSE_TEST_USER, and CLICKHOUSE_TEST_PASSWORD"]
+async fn clickhouse_cloud_manager_catalogs_and_session_table() -> IdeResult<()> {
+    let tmp = tempfile::tempdir()?;
+    let root = tmp.path().to_path_buf();
+    let ssh = Arc::new(ide_ssh::SshManager::new(root.join("ssh-passwords.json")));
+    let db = DbManager::new(root.clone(), root.join("passwords.json"), root.join("history.json"), ssh);
+    let mut source = DataSource {
+        id: "clickhouse".into(),
+        name: "clickhouse".into(),
+        driver: DbDriver::Clickhouse,
+        host: std::env::var("CLICKHOUSE_TEST_HOST").expect("set CLICKHOUSE_TEST_HOST"),
+        port: Some(
+            std::env::var("CLICKHOUSE_TEST_PORT")
+                .map(|value| value.parse().expect("numeric CLICKHOUSE_TEST_PORT"))
+                .unwrap_or(8443),
+        ),
+        user: std::env::var("CLICKHOUSE_TEST_USER").expect("set CLICKHOUSE_TEST_USER"),
+        database: "default".into(),
+        ssl: DbSslMode::VerifyFull,
+        ..Default::default()
+    };
+    source.introspection.show_system = true;
+    let password = std::env::var("CLICKHOUSE_TEST_PASSWORD").expect("set CLICKHOUSE_TEST_PASSWORD");
+    check(!db.test(&source, Some(password.clone()), None).await?.is_empty(), "missing server version")?;
+    db.save_sources(vec![source]).await?;
+    db.set_password("clickhouse", Some(password), false).await?;
+    let cancel = CancellationToken::new();
+    let suffix = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos();
+    let name = format!("manager_test_{}_{suffix}", std::process::id());
+    let table = sql::quote_ident(DbDriver::Clickhouse, &name);
+    db.execute(
+        "clickhouse",
+        &format!(
+            "CREATE TEMPORARY TABLE {table} (id UInt64, label Nullable(String) DEFAULT NULL, \
+             category LowCardinality(Nullable(String)) DEFAULT NULL, items Array(Nullable(UInt8)), \
+             label_size UInt64 ALIAS length(ifNull(label, ''))) ENGINE = Memory"
+        ),
+        0,
+        &cancel,
+    )
+    .await?;
+    let checked: IdeResult<()> = async {
+        db.execute(
+            "clickhouse",
+            &format!("INSERT INTO {table} (id, label, items) VALUES (1, 'first', [1, NULL]), (1, NULL, [])"),
+            0,
+            &cancel,
+        )
+        .await?;
+        let schemas = db.schemas("clickhouse").await?;
+        check(schemas.iter().any(|schema| schema == "default"), "default database missing")?;
+        check(schemas.iter().any(|schema| schema == "system"), "system database missing")?;
+        let tables = db.tables("clickhouse", "system").await?;
+        check(tables.iter().any(|table| table.name == "one"), "system table listing missing one")?;
+        let details = db.table_details("clickhouse", "", &name).await?;
+        check(details.columns.len() == 5, "temporary table columns missing")?;
+        for (name, data_type, nullable) in [
+            ("id", "UInt64", false),
+            ("label", "Nullable(String)", true),
+            ("category", "LowCardinality(Nullable(String))", true),
+            ("items", "Array(Nullable(UInt8))", false),
+        ] {
+            check(
+                details
+                    .columns
+                    .iter()
+                    .any(|column| column.name == name && column.data_type == data_type && column.nullable == nullable),
+                "column type or nullability mismatch",
+            )?;
+        }
+        check(
+            details.columns.iter().any(|column| column.name == "label" && column.default.as_deref() == Some("NULL")),
+            "explicit default expression missing",
+        )?;
+        check(details.indexes.iter().all(|index| !index.unique), "ClickHouse index reported unique")?;
+        check(details.foreign_keys.is_empty() && details.triggers.is_empty(), "unsupported table objects returned")?;
+        let sort = [SortKey { column: "id".into(), descending: false }];
+        let first = db.table_page("clickhouse", "", &name, None, &sort, 0, 1, &cancel).await?;
+        check(first.result.rows.len() == 1 && first.result.has_more, "first page limit failed")?;
+        let second = db.table_page("clickhouse", "", &name, None, &sort, 1, 1, &cancel).await?;
+        check(second.result.rows.len() == 1 && !second.result.has_more, "page offset failed")?;
+        let ddl = db.ddl("clickhouse", "", &name).await?;
+        check(ddl.contains(&name) && ddl.contains("Memory"), "temporary table DDL missing")?;
+        let completion = db.completion("clickhouse").await?;
+        check(completion.default_schema == "default", "completion default database mismatch")?;
+        check(completion.foreign_keys.is_empty(), "completion returned unsupported foreign keys")?;
+        if let Some(table) = completion.tables.first() {
+            let details = db.table_details("clickhouse", &table.schema, &table.name).await?;
+            check(
+                table.columns.iter().all(|column| {
+                    details.columns.iter().any(|field| field.name == column.name && field.data_type == column.data_type)
+                }),
+                "completion columns differ from catalog",
+            )?;
+        }
+        let plan = db.explain("clickhouse", &format!("SELECT id FROM {table}"), &cancel).await?;
+        check(!plan.is_empty(), "query plan missing")?;
+        let value = r"path\O'Brien";
+        let result = db
+            .execute("clickhouse", &format!("SELECT {}", sql::quote_literal(DbDriver::Clickhouse, value)), 1, &cancel)
+            .await?;
+        check(result.rows == vec![vec![Some(value.to_owned())]], "quoted literal changed value")?;
+        let edits = [DbRowEdit::Update {
+            key: vec![CellValue { column: "id".into(), value: Some("1".into()) }],
+            values: vec![CellValue { column: "label".into(), value: Some("changed".into()) }],
+        }];
+        check(
+            db.apply_edits("clickhouse", "", &name, &edits)
+                .await
+                .err()
+                .is_some_and(|error| error.message.contains("table editing is unsupported")),
+            "supplied row key authorized table editing",
+        )?;
+        check(db.set_manual_commit("clickhouse", true).await.is_err(), "manual transactions were accepted")?;
+        for commit in [false, true] {
+            check(db.finish_transaction("clickhouse", commit).await.is_err(), "transaction control was accepted")?;
+        }
+        Ok(())
+    }
+    .await;
+    let cleanup = db.execute("clickhouse", &format!("DROP TEMPORARY TABLE {table}"), 0, &cancel).await;
+    db.disconnect("clickhouse").await;
+    checked?;
+    cleanup?;
+    Ok(())
+}

crates/ide-db/tests/sqlite.rs

@@ -197,7 +197,7 @@ async fn count(db: &DbManager) -> String {
 async fn manual_commit_keeps_a_transaction_until_commit_or_rollback() -> IdeResult<()> {
     let (_tmp, db) = setup().await;
     let c = CancellationToken::new();
-    db.set_manual_commit("s1", true).await;
+    db.set_manual_commit("s1", true).await.unwrap();
     db.execute("s1", "INSERT INTO users (name) VALUES ('dee')", 1, &c).await?;
     // The session sees its own change.
     assert_eq!(count(&db).await, "4");
@@ -208,10 +208,10 @@ async fn manual_commit_keeps_a_transaction_until_commit_or_rollback() -> IdeResu
     db.finish_transaction("s1", true).await?;
     // Leaving manual mode rolls back what is still open.
     db.execute("s1", "DELETE FROM users", 1, &c).await?;
-    db.set_manual_commit("s1", false).await;
+    db.set_manual_commit("s1", false).await.unwrap();
     assert_eq!(count(&db).await, "4");
     // Disconnecting with an open transaction does not hang.
-    db.set_manual_commit("s1", true).await;
+    db.set_manual_commit("s1", true).await.unwrap();
     db.execute("s1", "DELETE FROM users", 1, &c).await?;
     db.disconnect("s1").await;
     assert_eq!(count(&db).await, "4");

crates/ide-extension/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "ide-extension"
+description = "Plugin manifest, extension points, contribution registry and capability model (no Wasm runtime)"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
+ide-core.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+specta.workspace = true
+specta-typescript.workspace = true
+toml.workspace = true
+tracing.workspace = true
+parking_lot.workspace = true
+semver = "1"
+blake3.workspace = true
+zip.workspace = true
+base64.workspace = true
+ed25519-dalek = "3"
+
+[dev-dependencies]
+tempfile.workspace = true

crates/ide-extension/src/capability.rs

@@ -0,0 +1,277 @@
+//! What a plugin may do beyond pure computation, and how risky each grant is.
+//!
+//! Capabilities are written as strings in the manifest (`project.read`,
+//! `net:crates.io`, `process:cargo`) and stored the same way in the grant
+//! ledger. The 0.1 permission names (`project-read`, …) parse as their 0.2
+//! equivalents.
+
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use specta::Type;
+use std::fmt;
+use std::str::FromStr;
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Capability {
+    /// Read files inside the project root; the project root itself.
+    ProjectRead,
+    /// The focused editor's file, selection and text.
+    EditorRead,
+    /// Edit the focused editor (versioned edits).
+    EditorWrite,
+    VcsRead,
+    VcsWrite,
+    /// The plugin's own key-value store and data directory.
+    Storage,
+    /// The plugin's own secrets (kept in the client's OS keychain).
+    Secrets,
+    /// Workbench events (file opened, saved, focus…), not keystrokes.
+    Events,
+    /// Keystrokes and editor input events.
+    InputEvents,
+    /// The system clipboard, from the plugin's web views.
+    Clipboard,
+    /// HTTP(S) to one host (`*.example.com` matches subdomains).
+    Net(String),
+    /// Run one external program. Full code execution: never fine-grained.
+    Process(String),
+    /// Read files outside the project under one path.
+    FsRead(String),
+}
+
+/// How a grant is presented (plan 4.2).
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub enum Risk {
+    /// Listed on the install page, one confirmation.
+    Low,
+    /// Listed separately with its purpose.
+    Medium,
+    /// Separate dialog: "equivalent to running arbitrary code on this machine".
+    High,
+}
+
+impl Capability {
+    pub fn risk(&self) -> Risk {
+        match self {
+            Self::ProjectRead | Self::EditorRead | Self::Storage | Self::Events | Self::VcsRead => Risk::Low,
+            Self::EditorWrite | Self::VcsWrite | Self::Net(_) | Self::Secrets | Self::InputEvents | Self::Clipboard => {
+                Risk::Medium
+            }
+            Self::Process(_) | Self::FsRead(_) => Risk::High,
+        }
+    }
+
+    /// Low-risk capabilities that the one-time migration of the 0.1 "declared
+    /// means granted" behaviour may grant automatically (plan 4.6).
+    pub fn auto_migrates(&self) -> bool {
+        self.risk() == Risk::Low
+    }
+
+    /// Short user-facing description for install and grant pages.
+    pub fn describe(&self) -> String {
+        match self {
+            Self::ProjectRead => "Read files in the open project".into(),
+            Self::EditorRead => "Read the focused editor's file and selection".into(),
+            Self::EditorWrite => "Change text in the editor".into(),
+            Self::VcsRead => "Read version control state".into(),
+            Self::VcsWrite => "Change version control state (commit, fetch, checkout)".into(),
+            Self::Storage => "Store its own data".into(),
+            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::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"),
+        }
+    }
+
+    /// Whether `self`, granted, also covers `wanted` (`net:*.x.com` covers `net:a.x.com`).
+    pub fn covers(&self, wanted: &Capability) -> bool {
+        match (self, wanted) {
+            (Self::Net(pattern), Self::Net(host)) => host_matches(pattern, host),
+            (Self::FsRead(base), Self::FsRead(path)) => {
+                std::path::Path::new(path).starts_with(std::path::Path::new(base))
+            }
+            _ => self == wanted,
+        }
+    }
+}
+
+/// `example.com` matches exactly; `*.example.com` matches any subdomain (not the apex).
+pub fn host_matches(pattern: &str, host: &str) -> bool {
+    let host = host.trim_end_matches('.').to_ascii_lowercase();
+    let pattern = pattern.to_ascii_lowercase();
+    match pattern.strip_prefix("*.") {
+        Some(suffix) => host.len() > suffix.len() + 1 && host.ends_with(&format!(".{suffix}")),
+        None => host == pattern,
+    }
+}
+
+impl fmt::Display for Capability {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::ProjectRead => f.write_str("project.read"),
+            Self::EditorRead => f.write_str("editor.read"),
+            Self::EditorWrite => f.write_str("editor.write"),
+            Self::VcsRead => f.write_str("vcs.read"),
+            Self::VcsWrite => f.write_str("vcs.write"),
+            Self::Storage => f.write_str("storage"),
+            Self::Secrets => f.write_str("secrets"),
+            Self::Events => f.write_str("events"),
+            Self::InputEvents => f.write_str("events.input"),
+            Self::Clipboard => f.write_str("clipboard"),
+            Self::Net(h) => write!(f, "net:{h}"),
+            Self::Process(b) => write!(f, "process:{b}"),
+            Self::FsRead(p) => write!(f, "fs.read:{p}"),
+        }
+    }
+}
+
+impl FromStr for Capability {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, String> {
+        let s = s.trim();
+        if let Some((kind, arg)) = s.split_once(':') {
+            let arg = arg.trim();
+            if arg.is_empty() {
+                return Err(format!("capability {s:?} needs a value after ':'"));
+            }
+            return match kind {
+                "net" => {
+                    let host = arg.strip_prefix("*.").unwrap_or(arg);
+                    let valid = !host.is_empty()
+                        && host.len() <= 253
+                        && host.split('.').all(|label| {
+                            !label.is_empty()
+                                && label.len() <= 63
+                                && label.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-')
+                        });
+                    if valid { Ok(Self::Net(arg.to_ascii_lowercase())) } else { Err(format!("invalid host in {s:?}")) }
+                }
+                "process" => {
+                    if arg.contains(['/', '\\']) && !std::path::Path::new(arg).is_absolute() {
+                        return Err(format!("{s:?}: use a program name or an absolute path"));
+                    }
+                    Ok(Self::Process(arg.to_owned()))
+                }
+                "fs.read" => {
+                    if !std::path::Path::new(arg).is_absolute() && !arg.starts_with('~') {
+                        return Err(format!("{s:?}: use an absolute path (or ~/…)"));
+                    }
+                    Ok(Self::FsRead(arg.to_owned()))
+                }
+                _ => Err(format!("unknown capability {s:?}")),
+            };
+        }
+        Ok(match s {
+            "project.read" | "project-read" => Self::ProjectRead,
+            "editor.read" | "editor-read" => Self::EditorRead,
+            "editor.write" | "editor-write" => Self::EditorWrite,
+            "vcs.read" => Self::VcsRead,
+            "vcs.write" => Self::VcsWrite,
+            "storage" => Self::Storage,
+            "secrets" => Self::Secrets,
+            "events" => Self::Events,
+            "events.input" => Self::InputEvents,
+            "clipboard" => Self::Clipboard,
+            _ => return Err(format!("unknown capability {s:?}")),
+        })
+    }
+}
+
+impl Serialize for Capability {
+    fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+        s.collect_str(self)
+    }
+}
+
+impl<'de> Deserialize<'de> for Capability {
+    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+        String::deserialize(d)?.parse().map_err(serde::de::Error::custom)
+    }
+}
+
+/// A capability as the UI shows it.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct CapabilityInfo {
+    /// `project.read`, `net:crates.io`, …
+    pub id: String,
+    pub risk: Risk,
+    pub description: String,
+    /// Declared under `optional`: the plugin runs without it.
+    pub optional: bool,
+    /// Currently granted.
+    pub granted: bool,
+}
+
+impl CapabilityInfo {
+    pub fn new(cap: &Capability, optional: bool, granted: bool) -> Self {
+        Self { id: cap.to_string(), risk: cap.risk(), description: cap.describe(), optional, granted }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_and_prints() {
+        for s in [
+            "project.read",
+            "editor.write",
+            "vcs.write",
+            "storage",
+            "secrets",
+            "events",
+            "events.input",
+            "net:crates.io",
+            "net:*.github.com",
+            "process:cargo",
+        ] {
+            assert_eq!(s.parse::<Capability>().unwrap().to_string(), s);
+        }
+        // Absolute paths are the platform's.
+        let (git, etc) = if cfg!(windows) {
+            (r"process:C:\Program Files\Git\bin\git.exe", r"fs.read:C:\Windows")
+        } else {
+            ("process:/usr/bin/git", "fs.read:/etc")
+        };
+        for s in [git, etc] {
+            assert_eq!(s.parse::<Capability>().unwrap().to_string(), s);
+        }
+        assert_eq!("project-read".parse::<Capability>().unwrap(), Capability::ProjectRead);
+        assert!("net:".parse::<Capability>().is_err());
+        assert!("net:a b".parse::<Capability>().is_err());
+        assert!("process:./evil".parse::<Capability>().is_err());
+        assert!("fs.read:rel".parse::<Capability>().is_err());
+        assert!("network".parse::<Capability>().is_err());
+    }
+
+    #[test]
+    fn risk_levels() {
+        assert_eq!(Capability::ProjectRead.risk(), Risk::Low);
+        assert_eq!(Capability::Net("x".into()).risk(), Risk::Medium);
+        assert_eq!(Capability::InputEvents.risk(), Risk::Medium);
+        assert_eq!("clipboard".parse::<Capability>().unwrap(), Capability::Clipboard);
+        assert_eq!(Capability::Clipboard.risk(), Risk::Medium);
+        assert_eq!(Capability::Process("cargo".into()).risk(), Risk::High);
+        assert!(Capability::Storage.auto_migrates() && !Capability::EditorWrite.auto_migrates());
+    }
+
+    #[test]
+    fn host_patterns() {
+        assert!(host_matches("crates.io", "crates.io"));
+        assert!(host_matches("crates.io", "CRATES.IO."));
+        assert!(!host_matches("crates.io", "static.crates.io"));
+        assert!(host_matches("*.github.com", "api.github.com"));
+        assert!(!host_matches("*.github.com", "github.com"));
+        assert!(!host_matches("*.github.com", "evilgithub.com"));
+        let any_gh: Capability = "net:*.github.com".parse().unwrap();
+        assert!(any_gh.covers(&"net:api.github.com".parse().unwrap()));
+        assert!(Capability::FsRead("/etc".into()).covers(&Capability::FsRead("/etc/hosts".into())));
+        assert!(!Capability::FsRead("/etc".into()).covers(&Capability::FsRead("/etcx".into())));
+    }
+}

crates/ide-extension/src/index.rs

@@ -0,0 +1,104 @@
+//! The contribution index: validated UI
+//! declarations of installed packages, kept on disk so start-up does not
+//! validate them again (sanitising thousands of icon SVGs, say).
+//!
+//! Only packages with a [`Package::digest`] are indexed: installed copies,
+//! which the host never modifies after install. An entry is keyed by that
+//! digest, the extension point, the declaration and a salt naming the
+//! validation logic (the IDE version), so a new package version, a changed
+//! declaration or an IDE upgrade simply misses. A miss or an unreadable entry
+//! only costs the validation.
+
+use crate::point::Package;
+use crate::ui::UiDecl;
+use std::collections::BTreeSet;
+use std::path::PathBuf;
+
+/// Bumped when [`UiDecl`]'s serialized shape changes.
+const FORMAT: u32 = 1;
+
+pub struct ContributionIndex {
+    dir: PathBuf,
+    salt: String,
+}
+
+impl ContributionIndex {
+    /// `salt` names the validators' version (the IDE version).
+    pub fn new(dir: PathBuf, salt: &str) -> Self {
+        Self { dir, salt: format!("{FORMAT}:{salt}") }
+    }
+
+    /// Entries start with a prefix of the package digest, for pruning.
+    fn file(&self, digest: &str, point: &str, decl: &toml::Value) -> PathBuf {
+        let mut h = blake3::Hasher::new();
+        for part in [self.salt.as_str(), digest, point, &decl.to_string()] {
+            h.update(part.as_bytes());
+            h.update(&[0]);
+        }
+        let key = h.finalize().to_hex();
+        self.dir.join(format!("{}-{}.json", prefix(digest), &key[..32]))
+    }
+
+    pub fn get(&self, pkg: &Package, point: &str, decl: &toml::Value) -> Option<UiDecl> {
+        let digest = pkg.digest.as_deref()?;
+        let bytes = std::fs::read(self.file(digest, point, decl)).ok()?;
+        serde_json::from_slice(&bytes).ok()
+    }
+
+    pub fn put(&self, pkg: &Package, point: &str, decl: &toml::Value, ui: &UiDecl) {
+        let Some(digest) = pkg.digest.as_deref() else { return };
+        let Ok(bytes) = serde_json::to_vec(ui) else { return };
+        let file = self.file(digest, point, decl);
+        let _ = std::fs::create_dir_all(&self.dir);
+        let tmp = file.with_extension(format!("tmp{}", std::process::id()));
+        if std::fs::write(&tmp, bytes).and_then(|()| std::fs::rename(&tmp, &file)).is_err() {
+            let _ = std::fs::remove_file(&tmp);
+        }
+    }
+
+    /// Removes entries of packages other than `live` (digests).
+    pub fn prune<'a>(&self, live: impl IntoIterator<Item = &'a str>) {
+        let keep: BTreeSet<String> = live.into_iter().map(|d| prefix(d).to_owned()).collect();
+        let Ok(entries) = std::fs::read_dir(&self.dir) else { return };
+        for e in entries.flatten() {
+            let name = e.file_name().to_string_lossy().into_owned();
+            if !name.split_once('-').is_some_and(|(p, _)| keep.contains(p)) {
+                let _ = std::fs::remove_file(e.path());
+            }
+        }
+    }
+}
+
+fn prefix(digest: &str) -> &str {
+    let d = digest.strip_prefix("blake3:").unwrap_or(digest);
+    let end = d.char_indices().nth(16).map_or(d.len(), |(i, _)| i);
+    &d[..end]
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::manifest::Manifest;
+
+    #[test]
+    fn hits_only_the_same_package_point_declaration_and_salt() {
+        let tmp = tempfile::tempdir().unwrap();
+        let index = ContributionIndex::new(tmp.path().join("idx"), "1.0");
+        let manifest =
+            Manifest::parse("id = \"p\"\nname = \"P\"\nversion = \"1.0.0\"\nengines.openidea = \"^1.0\"\n").unwrap();
+        let pkg = Package::new(manifest, tmp.path().to_path_buf()).with_digest("blake3:00aa11bb22cc33dd44ee");
+        let decl: toml::Value = toml::from_str("id = \"x\"").unwrap();
+        let ui = UiDecl::new("x", "X", serde_json::json!({ "id": "x" }));
+        assert!(index.get(&pkg, "pt", &decl).is_none());
+        index.put(&pkg, "pt", &decl, &ui);
+        assert_eq!(index.get(&pkg, "pt", &decl).unwrap().label, "X");
+        assert!(index.get(&pkg, "other", &decl).is_none());
+        assert!(index.get(&pkg, "pt", &toml::from_str("id = \"y\"").unwrap()).is_none());
+        assert!(ContributionIndex::new(tmp.path().join("idx"), "1.1").get(&pkg, "pt", &decl).is_none());
+        let unhashed = Package { digest: None, ..pkg.clone() };
+        assert!(index.get(&unhashed, "pt", &decl).is_none(), "not an installed copy");
+
+        index.prune(["blake3:ffff"]);
+        assert!(index.get(&pkg, "pt", &decl).is_none());
+    }
+}

crates/ide-extension/src/ledger.rs

@@ -0,0 +1,483 @@
+//! The grant ledger (plan 4.6): which capabilities the user granted to which
+//! plugin, saved as `grants.json` next to the installed plugins.
+//!
+//! - Installed plugins are keyed by id and remember the version and package
+//!   hash they were confirmed for. An update that needs no new capability is
+//!   accepted silently; one that does must be confirmed again.
+//! - Linked development plugins and project plugins (`.openidea/plugins/*`)
+//!   are keyed by their directory, not by hash, so rebuilding does not ask
+//!   again; new capabilities still do.
+//! - `process:<program>` grants record the program's absolute path and file
+//!   hash at grant time. Calls use that path, never a `PATH` lookup, and fail
+//!   when the file changed (re-confirmation needed).
+
+use crate::capability::{Capability, Risk};
+use serde::{Deserialize, Serialize};
+use std::collections::{BTreeMap, BTreeSet};
+use std::ffi::OsStr;
+use std::path::{Path, PathBuf};
+
+pub const LEDGER_FILE: &str = "grants.json";
+const FORMAT: u32 = 1;
+
+/// Whose grant an entry is.
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+#[serde(tag = "kind", content = "value", rename_all = "camelCase")]
+pub enum Subject {
+    /// Installed under the plugins directory, by plugin id.
+    Installed(String),
+    /// A linked development plugin or a project plugin, by package directory.
+    Path(PathBuf),
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BinaryGrant {
+    pub path: PathBuf,
+    /// blake3 of the file when granted.
+    pub hash: String,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Grant {
+    pub plugin_id: String,
+    /// The version and package hash the user confirmed (installed plugins).
+    #[serde(default)]
+    pub version: String,
+    #[serde(default)]
+    pub package_hash: String,
+    /// The user confirmed the plugin (the install page or the project-plugin prompt).
+    #[serde(default)]
+    pub confirmed: bool,
+    /// Granted capabilities (`project.read`, `net:x`, …).
+    #[serde(default)]
+    pub granted: BTreeSet<String>,
+    /// Optional capabilities the user declined (not asked again until re-confirmed).
+    #[serde(default)]
+    pub declined: BTreeSet<String>,
+    /// `process:<program>` → the program confirmed for it.
+    #[serde(default)]
+    pub binaries: BTreeMap<String, BinaryGrant>,
+    /// Migrated from 0.1: capabilities not granted yet are asked for on first
+    /// use instead of blocking the plugin from loading.
+    #[serde(default)]
+    pub ask_on_use: bool,
+}
+
+impl Grant {
+    pub fn has(&self, cap: &Capability) -> bool {
+        self.granted.iter().filter_map(|s| s.parse::<Capability>().ok()).any(|g| g.covers(cap))
+    }
+}
+
+/// What a plugin (in its current form) needs, to compare with its grant.
+#[derive(Clone, Debug)]
+pub struct Request<'a> {
+    pub subject: Subject,
+    pub plugin_id: &'a str,
+    pub version: &'a str,
+    pub package_hash: &'a str,
+    pub required: Vec<Capability>,
+    pub optional: Vec<Capability>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Decision {
+    /// Load with these capabilities. `pending` required ones are asked for when
+    /// the plugin is first used (plugins migrated from 0.1 only).
+    Allowed { granted: Vec<Capability>, pending: Vec<Capability> },
+    /// Ask the user first. `new` lists what was never granted (all of it on first use).
+    NeedsConfirmation { new: Vec<Capability>, first_time: bool },
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct File {
+    #[serde(default)]
+    format: u32,
+    /// The one-time migration from 0.1 ("declared means granted") ran.
+    #[serde(default)]
+    migrated: bool,
+    #[serde(default)]
+    grants: Vec<(Subject, Grant)>,
+}
+
+/// The ledger, loaded into memory; [`Ledger::save`] writes it atomically.
+#[derive(Debug, Default)]
+pub struct Ledger {
+    path: Option<PathBuf>,
+    migrated: bool,
+    grants: BTreeMap<Subject, Grant>,
+}
+
+impl Ledger {
+    /// Loads `<dir>/grants.json`; a missing or unreadable file gives an empty
+    /// ledger with `needs_migration()` true.
+    pub fn load(dir: &Path) -> Self {
+        let path = dir.join(LEDGER_FILE);
+        let file: Option<File> = std::fs::read_to_string(&path).ok().and_then(|s| match serde_json::from_str(&s) {
+            Ok(f) => Some(f),
+            Err(e) => {
+                tracing::warn!("{}: {e}; starting with an empty grant ledger", path.display());
+                None
+            }
+        });
+        let existed = file.is_some();
+        let file = file.unwrap_or_default();
+        Self { path: Some(path), migrated: file.migrated || existed, grants: file.grants.into_iter().collect() }
+    }
+
+    pub fn in_memory() -> Self {
+        Self { path: None, migrated: true, grants: BTreeMap::new() }
+    }
+
+    pub fn save(&self) -> std::io::Result<()> {
+        let Some(path) = &self.path else { return Ok(()) };
+        let file = File {
+            format: FORMAT,
+            migrated: self.migrated,
+            grants: self.grants.iter().map(|(s, g)| (s.clone(), g.clone())).collect(),
+        };
+        let json = serde_json::to_string_pretty(&file).map_err(std::io::Error::other)?;
+        let tmp = path.with_extension("json.tmp");
+        std::fs::write(&tmp, json)?;
+        std::fs::rename(&tmp, path)
+    }
+
+    pub fn get(&self, subject: &Subject) -> Option<&Grant> {
+        self.grants.get(subject)
+    }
+
+    pub fn remove(&mut self, subject: &Subject) -> Option<Grant> {
+        self.grants.remove(subject)
+    }
+
+    /// Puts back an earlier state of `subject`'s grant (`None`: none), e.g.
+    /// after rolling back an update.
+    pub fn restore(&mut self, subject: &Subject, grant: Option<Grant>) {
+        match grant {
+            Some(g) => {
+                self.grants.insert(subject.clone(), g);
+            }
+            None => {
+                self.grants.remove(subject);
+            }
+        }
+    }
+
+    /// The one-time migration of 0.1's "declared means granted" has not run yet.
+    pub fn needs_migration(&self) -> bool {
+        !self.migrated
+    }
+
+    /// Migrates plugins installed before the ledger existed: low-risk
+    /// capabilities are granted, the rest are asked on first use.
+    pub fn migrate(&mut self, installed: &[Request<'_>]) {
+        for req in installed {
+            let granted: BTreeSet<String> =
+                req.required.iter().chain(&req.optional).filter(|c| c.auto_migrates()).map(|c| c.to_string()).collect();
+            self.grants.entry(req.subject.clone()).or_insert_with(|| Grant {
+                plugin_id: req.plugin_id.to_owned(),
+                version: req.version.to_owned(),
+                package_hash: req.package_hash.to_owned(),
+                confirmed: true,
+                granted,
+                ask_on_use: true,
+                ..Grant::default()
+            });
+        }
+        self.migrated = true;
+    }
+
+    /// Compares what the plugin needs with what was granted.
+    pub fn decide(&mut self, req: &Request<'_>) -> Decision {
+        let Some(grant) = self.grants.get_mut(&req.subject) else {
+            return Decision::NeedsConfirmation { new: req.required.clone(), first_time: true };
+        };
+        if !grant.confirmed {
+            return Decision::NeedsConfirmation { new: req.required.clone(), first_time: true };
+        }
+        let new: Vec<Capability> = req.required.iter().filter(|c| !grant.has(c)).cloned().collect();
+        if !new.is_empty() && !grant.ask_on_use {
+            return Decision::NeedsConfirmation { new, first_time: false };
+        }
+        // Same or fewer needs: accept an update silently (plan 4.6).
+        if grant.version != req.version || grant.package_hash != req.package_hash {
+            grant.version = req.version.to_owned();
+            grant.package_hash = req.package_hash.to_owned();
+        }
+        let granted = req.required.iter().chain(&req.optional).filter(|c| grant.has(c)).cloned().collect();
+        Decision::Allowed { granted, pending: new }
+    }
+
+    /// Records the user's confirmation: `required` plus the accepted optional capabilities.
+    pub fn confirm(
+        &mut self,
+        req: &Request<'_>,
+        accepted_optional: &[Capability],
+        binaries: BTreeMap<String, BinaryGrant>,
+    ) {
+        let grant = self.grants.entry(req.subject.clone()).or_default();
+        grant.plugin_id = req.plugin_id.to_owned();
+        grant.version = req.version.to_owned();
+        grant.package_hash = req.package_hash.to_owned();
+        grant.confirmed = true;
+        grant.ask_on_use = false;
+        for cap in req.required.iter().chain(accepted_optional) {
+            grant.granted.insert(cap.to_string());
+        }
+        for cap in &req.optional {
+            let s = cap.to_string();
+            if accepted_optional.contains(cap) {
+                grant.declined.remove(&s);
+            } else if !grant.granted.contains(&s) {
+                grant.declined.insert(s);
+            }
+        }
+        grant.binaries.extend(binaries);
+    }
+
+    /// Grants or revokes one capability (Settings › Plugins › permissions).
+    pub fn set(&mut self, subject: &Subject, cap: &Capability, granted: bool) -> bool {
+        let Some(grant) = self.grants.get_mut(subject) else { return false };
+        let s = cap.to_string();
+        if granted {
+            grant.declined.remove(&s);
+            grant.granted.insert(s)
+        } else {
+            if let Capability::Process(_) = cap {
+                grant.binaries.remove(&s);
+            }
+            grant.granted.remove(&s)
+        }
+    }
+
+    /// Records the program approved for a `process:` grant.
+    pub fn set_binary(&mut self, subject: &Subject, cap: &Capability, binary: BinaryGrant) {
+        if let Some(grant) = self.grants.get_mut(subject) {
+            grant.binaries.insert(cap.to_string(), binary);
+        }
+    }
+
+    /// Checks a `process:` grant at call time: the program confirmed for it,
+    /// unchanged since. Errors name what to do.
+    pub fn check_binary(&self, subject: &Subject, cap: &Capability) -> Result<PathBuf, String> {
+        let Capability::Process(name) = cap else { return Err(format!("{cap} is not a process capability")) };
+        let grant = self.grants.get(subject).ok_or_else(|| format!("{cap} was not granted"))?;
+        let key = cap.to_string();
+        if !grant.granted.contains(&key) {
+            return Err(format!("{cap} was not granted"));
+        }
+        let bin = grant.binaries.get(&key).ok_or_else(|| format!("{cap}: no program was confirmed for {name}"))?;
+        match file_hash(&bin.path) {
+            Ok(hash) if hash == bin.hash => Ok(bin.path.clone()),
+            Ok(_) => Err(format!(
+                "{} changed since it was approved for {cap}; confirm the plugin's permissions again",
+                bin.path.display()
+            )),
+            Err(e) => Err(format!("{}: {e}; confirm the plugin's permissions again", bin.path.display())),
+        }
+    }
+
+    /// The program approved for a granted `process:` capability, without
+    /// checking the file: whoever starts it verifies the hash then
+    /// ([`check_binary`](Self::check_binary) or the pin's own check).
+    pub fn pinned_binary(&self, subject: &Subject, cap: &Capability) -> Option<BinaryGrant> {
+        let grant = self.grants.get(subject)?;
+        let key = cap.to_string();
+        if !grant.granted.contains(&key) {
+            return None;
+        }
+        grant.binaries.get(&key).cloned()
+    }
+
+    pub fn subjects(&self) -> impl Iterator<Item = (&Subject, &Grant)> {
+        self.grants.iter()
+    }
+}
+
+/// What a confirmation page shows: every capability with its risk, high risk first.
+pub fn by_risk(caps: &[Capability]) -> Vec<(Risk, Vec<Capability>)> {
+    let mut groups: BTreeMap<std::cmp::Reverse<Risk>, Vec<Capability>> = BTreeMap::new();
+    for c in caps {
+        groups.entry(std::cmp::Reverse(c.risk())).or_default().push(c.clone());
+    }
+    groups.into_iter().map(|(r, v)| (r.0, v)).collect()
+}
+
+/// Resolves a `process:` program to an absolute path once, at grant time:
+/// absolute names are taken as is, others are looked up in `path_var`.
+pub fn resolve_program(name: &str, path_var: Option<&OsStr>) -> Result<PathBuf, String> {
+    let candidate = Path::new(name);
+    if candidate.is_absolute() {
+        return if candidate.is_file() { Ok(candidate.to_path_buf()) } else { Err(format!("{name}: no such program")) };
+    }
+    let exts: Vec<String> = if cfg!(windows) {
+        std::env::var("PATHEXT").unwrap_or_else(|_| ".EXE;.CMD;.BAT".into()).split(';').map(str::to_owned).collect()
+    } else {
+        vec![String::new()]
+    };
+    for dir in std::env::split_paths(path_var.unwrap_or_default()) {
+        if !dir.is_absolute() {
+            continue; // `.` or relative entries could point into the project
+        }
+        for ext in &exts {
+            let p = dir.join(format!("{name}{ext}"));
+            if is_executable(&p) {
+                return Ok(dunce_canonical(&p));
+            }
+        }
+    }
+    Err(format!("{name} was not found on PATH"))
+}
+
+fn dunce_canonical(p: &Path) -> PathBuf {
+    std::fs::canonicalize(p).unwrap_or_else(|_| p.to_path_buf())
+}
+
+fn is_executable(p: &Path) -> bool {
+    let Ok(meta) = std::fs::metadata(p) else { return false };
+    if !meta.is_file() {
+        return false;
+    }
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        meta.permissions().mode() & 0o111 != 0
+    }
+    #[cfg(not(unix))]
+    true
+}
+
+/// blake3 of a file, hex.
+pub fn file_hash(path: &Path) -> std::io::Result<String> {
+    let mut hasher = blake3::Hasher::new();
+    hasher.update_reader(std::fs::File::open(path)?)?;
+    Ok(hasher.finalize().to_hex().to_string())
+}
+
+/// blake3 over a package's files (sorted relative paths and contents).
+pub fn package_hash(dir: &Path, files: &[PathBuf]) -> std::io::Result<String> {
+    let mut sorted: Vec<&PathBuf> = files.iter().collect();
+    sorted.sort();
+    sorted.dedup();
+    let mut hasher = blake3::Hasher::new();
+    for rel in sorted {
+        hasher.update(rel.to_string_lossy().as_bytes());
+        hasher.update(&[0]);
+        hasher.update_reader(std::fs::File::open(dir.join(rel))?)?;
+        hasher.update(&[0]);
+    }
+    Ok(hasher.finalize().to_hex().to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn caps(list: &[&str]) -> Vec<Capability> {
+        list.iter().map(|s| s.parse().unwrap()).collect()
+    }
+
+    fn req<'a>(version: &'a str, hash: &'a str, required: &[&str], optional: &[&str]) -> Request<'a> {
+        Request {
+            subject: Subject::Installed("p".into()),
+            plugin_id: "p",
+            version,
+            package_hash: hash,
+            required: caps(required),
+            optional: caps(optional),
+        }
+    }
+
+    #[test]
+    fn confirmation_then_silent_update_then_reconfirm_on_new_capability() {
+        let mut l = Ledger::in_memory();
+        let r1 = req("1.0.0", "h1", &["project.read"], &["net:crates.io"]);
+        assert_eq!(l.decide(&r1), Decision::NeedsConfirmation { new: caps(&["project.read"]), first_time: true });
+        l.confirm(&r1, &[], BTreeMap::new());
+        assert_eq!(
+            l.decide(&r1),
+            Decision::Allowed { granted: caps(&["project.read"]), pending: vec![] },
+            "declined optional"
+        );
+        assert!(l.get(&r1.subject).unwrap().declined.contains("net:crates.io"));
+
+        // Same needs, new version: silent.
+        let r2 = req("1.1.0", "h2", &["project.read"], &["net:crates.io"]);
+        assert!(matches!(l.decide(&r2), Decision::Allowed { .. }));
+        assert_eq!(l.get(&r2.subject).unwrap().version, "1.1.0");
+
+        // A new required capability: ask again, only for it.
+        let r3 = req("1.2.0", "h3", &["project.read", "editor.write"], &[]);
+        assert_eq!(l.decide(&r3), Decision::NeedsConfirmation { new: caps(&["editor.write"]), first_time: false });
+        l.confirm(&r3, &[], BTreeMap::new());
+        assert!(matches!(l.decide(&r3), Decision::Allowed { .. }));
+
+        // Revoking a required capability blocks loading again.
+        assert!(l.set(&r3.subject, &Capability::EditorWrite, false));
+        assert!(matches!(l.decide(&r3), Decision::NeedsConfirmation { .. }));
+    }
+
+    #[test]
+    fn migration_grants_low_risk_only() {
+        let tmp = tempfile::tempdir().unwrap();
+        let mut l = Ledger::load(tmp.path());
+        assert!(l.needs_migration());
+        let r = req("0.1.0", "h", &["project.read", "editor.write"], &[]);
+        l.migrate(std::slice::from_ref(&r));
+        // Loads with the low-risk part; the rest is asked for on first use.
+        assert_eq!(
+            l.decide(&r),
+            Decision::Allowed { granted: caps(&["project.read"]), pending: caps(&["editor.write"]) }
+        );
+        l.confirm(&r, &[], BTreeMap::new());
+        assert_eq!(
+            l.decide(&r),
+            Decision::Allowed { granted: caps(&["project.read", "editor.write"]), pending: vec![] }
+        );
+        l.save().unwrap();
+        let again = Ledger::load(tmp.path());
+        assert!(!again.needs_migration());
+        assert!(again.get(&r.subject).unwrap().has(&Capability::ProjectRead));
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn binaries_are_pinned_by_path_and_hash() {
+        use std::os::unix::fs::PermissionsExt;
+        let tmp = tempfile::tempdir().unwrap();
+        let bin_dir = tmp.path().join("bin");
+        std::fs::create_dir(&bin_dir).unwrap();
+        let tool = bin_dir.join("tool");
+        std::fs::write(&tool, "#!/bin/sh\necho v1\n").unwrap();
+        std::fs::set_permissions(&tool, std::fs::Permissions::from_mode(0o755)).unwrap();
+        let path_var = std::env::join_paths([PathBuf::from("relative"), bin_dir.clone()]).unwrap();
+        let resolved = resolve_program("tool", Some(&path_var)).unwrap();
+        assert!(resolved.is_absolute());
+        assert!(resolve_program("missing", Some(&path_var)).is_err());
+
+        let mut l = Ledger::in_memory();
+        let r = req("1.0.0", "h", &["process:tool"], &[]);
+        let cap: Capability = "process:tool".parse().unwrap();
+        let bin = BinaryGrant { path: resolved.clone(), hash: file_hash(&resolved).unwrap() };
+        l.confirm(&r, &[], [(cap.to_string(), bin)].into());
+        assert_eq!(l.check_binary(&r.subject, &cap).unwrap(), resolved);
+        std::fs::write(&tool, "#!/bin/sh\necho evil\n").unwrap();
+        assert!(l.check_binary(&r.subject, &cap).unwrap_err().contains("changed"));
+    }
+
+    #[test]
+    fn hashes_and_grouping() {
+        let tmp = tempfile::tempdir().unwrap();
+        std::fs::write(tmp.path().join("a"), "1").unwrap();
+        std::fs::write(tmp.path().join("b"), "2").unwrap();
+        let h1 = package_hash(tmp.path(), &["a".into(), "b".into()]).unwrap();
+        assert_eq!(h1, package_hash(tmp.path(), &["b".into(), "a".into()]).unwrap());
+        std::fs::write(tmp.path().join("b"), "3").unwrap();
+        assert_ne!(h1, package_hash(tmp.path(), &["a".into(), "b".into()]).unwrap());
+        let groups = by_risk(&caps(&["storage", "process:git", "net:x.io"]));
+        assert_eq!(groups.iter().map(|g| g.0).collect::<Vec<_>>(), [Risk::High, Risk::Medium, Risk::Low]);
+    }
+}

crates/ide-extension/src/lib.rs

@@ -0,0 +1,36 @@
+//! The plugin system's kernel, independent of the Wasm runtime:
+//!
+//! - [`Manifest`]: `plugin.toml` (0.2 format; 0.1 still parses);
+//! - [`Capability`]: what a plugin may do, with its [`Risk`] level;
+//! - [`ExtensionPoint`]: one kind of contribution, implemented by the crate that
+//!   owns the feature; [`ExtensionRegistry`] validates a package's declarations
+//!   ([`ExtensionRegistry::prepare`], no side effects), makes them take effect
+//!   all or nothing ([`ExtensionRegistry::commit`]) and withdraws them per plugin;
+//! - [`UiStore`] / [`UiPoint`]: UI contributions, validated here and projected
+//!   by the client without the possibility to fail;
+//! - [`ledger`]: which capabilities the user granted to which plugin;
+//! - [`package`]: the package file, its signature and the marketplace index.
+//!
+//! Dependency direction: `ide-core` ← `ide-extension` ← feature crates (their
+//! extension points) and `ide-plugin` (Wasm) ← `ide-host` (assembly).
+
+mod capability;
+mod index;
+pub mod ledger;
+mod manifest;
+pub mod package;
+mod point;
+mod registry;
+mod ui;
+mod when;
+
+pub use capability::{Capability, CapabilityInfo, Risk, host_matches};
+pub use index::ContributionIndex;
+pub use manifest::{
+    ActivationEvent, CATEGORIES, Capabilities, ENGINE_VERSION, EVENT_KINDS, LEGACY_API, MANIFEST_FILE, MAX_CATEGORIES,
+    Manifest, check_relative, engine_compatible, validate_item_id, validate_plugin_id, validate_point_id,
+};
+pub use point::{Commit, Disposable, ExtensionPoint, MAX_PACKAGE_FILE, Package, Placement, Prepared, decode};
+pub use registry::{ContributionInfo, ExtensionRegistry, PreparedSet};
+pub use ui::{UiContribution, UiDecl, UiPoint, UiStore, to_json};
+pub use when::validate_when;

crates/ide-extension/src/manifest.rs

@@ -0,0 +1,567 @@
+//! `plugin.toml`, the package manifest (plan 4.4).
+//!
+//! ```toml
+//! id = "acme.rust-tools"          # optional publisher namespace before the first '.'
+//! name = "Rust Tools"
+//! version = "1.2.0"
+//! engines.openidea = "^1.0"
+//! wasm = "plugin.wasm"
+//! activation = ["on-language:rust", "on-command:check"]
+//!
+//! [capabilities]
+//! required = ["project.read", "editor.write"]
+//! optional = ["net:crates.io", "process:cargo"]
+//!
+//! [[contributes.commands]]
+//! id = "check"
+//! title = "Check"
+//! ```
+//!
+//! `contributes` is kept as raw TOML: each `contributes.<point>` is parsed and
+//! validated by the extension point registered under that id
+//! ([`crate::ExtensionRegistry`]), so new contribution types need no change here.
+//!
+//! Manifests in the 0.1 format (`openidea-api = "0.1"`, `permissions = [...]`)
+//! still parse: permissions become required capabilities and the plugin is
+//! activated at start-up, as before.
+
+use crate::capability::Capability;
+use serde::Deserialize;
+use std::collections::BTreeSet;
+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";
+/// 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.
+pub const CATEGORIES: &[&str] =
+    &["languages", "themes", "icon-themes", "linters", "vcs", "ai", "frameworks", "tools", "other"];
+/// Categories a plugin is listed under; later ones are ignored.
+pub const MAX_CATEGORIES: usize = 3;
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Manifest {
+    pub id: String,
+    pub name: String,
+    pub version: String,
+    pub description: String,
+    pub authors: Vec<String>,
+    pub homepage: Option<String>,
+    pub license: Option<String>,
+    /// Release notes of this version (Settings › Plugins › What's New).
+    pub change_notes: Option<String>,
+    /// Marketplace categories as declared (see [`Manifest::categories`]).
+    pub declared_categories: Vec<String>,
+    /// `engines.openidea` (a semver requirement), or the legacy `openidea-api`.
+    pub engine: String,
+    /// Written in the 0.1 format.
+    pub legacy: bool,
+    /// Component file relative to the package directory.
+    pub wasm: Option<PathBuf>,
+    pub activation: Vec<ActivationEvent>,
+    pub capabilities: Capabilities,
+    /// `contributes.<point>` → its declarations, validated by the extension points.
+    pub contributes: toml::Table,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct Capabilities {
+    pub required: Vec<Capability>,
+    pub optional: Vec<Capability>,
+}
+
+impl Capabilities {
+    pub fn all(&self) -> impl Iterator<Item = &Capability> {
+        self.required.iter().chain(&self.optional)
+    }
+
+    pub fn is_optional(&self, cap: &Capability) -> bool {
+        self.optional.contains(cap) && !self.required.contains(cap)
+    }
+}
+
+/// When a plugin's code is instantiated (plan 4.4). Contributions are live
+/// without it; code only runs once one of these fires.
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum ActivationEvent {
+    /// One of the plugin's commands is run (`on-command:<id>`; `*` = any).
+    Command(String),
+    /// A file of this language is opened.
+    Language(String),
+    /// A file matching this glob (project-relative) is opened.
+    File(String),
+    /// One of the plugin's views is shown.
+    View(String),
+    /// Periodically: `on-schedule:<seconds>`. Does not keep the plugin alive.
+    Schedule(u32),
+    /// A workbench event of this kind (`on-event:file-saved`): the plugin is
+    /// subscribed from the start, and activated to receive it.
+    Event(String),
+    /// Shortly after the workbench is ready.
+    StartupFinished,
+}
+
+impl ActivationEvent {
+    pub fn parse(s: &str) -> Result<Self, String> {
+        let s = s.trim();
+        if s == "on-startup-finished" {
+            return Ok(Self::StartupFinished);
+        }
+        let (kind, arg) = s.split_once(':').ok_or_else(|| format!("unknown activation event {s:?}"))?;
+        let arg = arg.trim();
+        if arg.is_empty() {
+            return Err(format!("activation event {s:?} needs a value"));
+        }
+        Ok(match kind {
+            "on-command" => Self::Command(arg.into()),
+            "on-language" => Self::Language(arg.into()),
+            "on-file" => Self::File(arg.into()),
+            "on-view" => Self::View(arg.into()),
+            "on-schedule" => {
+                let secs: u32 =
+                    arg.trim_end_matches('s').parse().map_err(|_| format!("{s:?}: expected seconds, e.g. 300"))?;
+                if secs < 60 {
+                    return Err(format!("{s:?}: the shortest schedule is 60 seconds"));
+                }
+                Self::Schedule(secs)
+            }
+            "on-event" => {
+                if !EVENT_KINDS.contains(&arg) {
+                    return Err(format!("{s:?}: unknown event kind (one of {})", EVENT_KINDS.join(", ")));
+                }
+                Self::Event(arg.into())
+            }
+            _ => return Err(format!("unknown activation event {s:?}")),
+        })
+    }
+}
+
+/// Workbench event kinds (`on-event:<kind>`, WIT `events.event-kind`).
+/// `scheduled` comes from `on-schedule` instead.
+pub const EVENT_KINDS: &[&str] = &["file-opened", "file-saved", "editor-focused", "action-performed", "vcs-changed"];
+
+impl std::fmt::Display for ActivationEvent {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Command(c) => write!(f, "on-command:{c}"),
+            Self::Language(l) => write!(f, "on-language:{l}"),
+            Self::File(g) => write!(f, "on-file:{g}"),
+            Self::View(v) => write!(f, "on-view:{v}"),
+            Self::Schedule(s) => write!(f, "on-schedule:{s}"),
+            Self::Event(k) => write!(f, "on-event:{k}"),
+            Self::StartupFinished => f.write_str("on-startup-finished"),
+        }
+    }
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+struct Raw {
+    id: String,
+    name: String,
+    version: String,
+    #[serde(default)]
+    description: String,
+    #[serde(default)]
+    authors: Vec<String>,
+    #[serde(default)]
+    homepage: Option<String>,
+    #[serde(default)]
+    license: Option<String>,
+    #[serde(default)]
+    change_notes: Option<String>,
+    #[serde(default)]
+    categories: Vec<String>,
+    #[serde(default)]
+    engines: Option<Engines>,
+    /// 0.1 format.
+    #[serde(default)]
+    openidea_api: Option<String>,
+    #[serde(default)]
+    wasm: Option<PathBuf>,
+    #[serde(default)]
+    activation: Option<Vec<String>>,
+    #[serde(default)]
+    capabilities: Option<RawCapabilities>,
+    /// 0.1 format.
+    #[serde(default)]
+    permissions: Option<Vec<String>>,
+    #[serde(default)]
+    contributes: toml::Table,
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct Engines {
+    openidea: String,
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct RawCapabilities {
+    #[serde(default)]
+    required: Vec<String>,
+    #[serde(default)]
+    optional: Vec<String>,
+}
+
+impl Manifest {
+    pub fn parse(src: &str) -> Result<Self, String> {
+        let raw: Raw = toml::from_str(src).map_err(|e| e.to_string())?;
+        let (engine, legacy) = match (raw.engines, raw.openidea_api) {
+            (Some(e), None) => (e.openidea, false),
+            (None, Some(api)) => (api, true),
+            (Some(_), Some(_)) => return Err("use `engines.openidea`, not `openidea-api`".into()),
+            (None, None) => return Err("missing `engines.openidea` (e.g. \"^1.0\")".into()),
+        };
+        if legacy && raw.capabilities.is_some() {
+            return Err("`capabilities` requires `engines.openidea`; 0.1 manifests use `permissions`".into());
+        }
+        if !legacy && raw.permissions.is_some() {
+            return Err("`permissions` is the 0.1 format; use `[capabilities] required = [...]`".into());
+        }
+        let parse_caps = |list: Vec<String>| -> Result<Vec<Capability>, String> {
+            let mut out: Vec<Capability> = Vec::new();
+            for s in list {
+                let cap: Capability = s.parse()?;
+                if !out.contains(&cap) {
+                    out.push(cap);
+                }
+            }
+            Ok(out)
+        };
+        let capabilities = match (raw.capabilities, raw.permissions) {
+            (Some(c), _) => Capabilities { required: parse_caps(c.required)?, optional: parse_caps(c.optional)? },
+            (None, Some(p)) => Capabilities { required: parse_caps(p)?, optional: Vec::new() },
+            (None, None) => Capabilities::default(),
+        };
+        let activation = match raw.activation {
+            Some(list) => list.iter().map(|s| ActivationEvent::parse(s)).collect::<Result<Vec<_>, _>>()?,
+            // 0.1 plugins were activated at start-up; keep that until they move to 1.0.
+            None if legacy && raw.wasm.is_some() => vec![ActivationEvent::StartupFinished],
+            None => Vec::new(),
+        };
+        let m = Manifest {
+            id: raw.id,
+            name: raw.name,
+            version: raw.version,
+            description: raw.description,
+            authors: raw.authors,
+            homepage: raw.homepage,
+            license: raw.license,
+            change_notes: raw.change_notes,
+            declared_categories: raw.categories,
+            engine,
+            legacy,
+            wasm: raw.wasm,
+            activation,
+            capabilities,
+            contributes: raw.contributes,
+        };
+        m.validate()?;
+        Ok(m)
+    }
+
+    pub fn load(dir: &Path) -> Result<Self, String> {
+        let path = dir.join(MANIFEST_FILE);
+        let src = std::fs::read_to_string(&path).map_err(|e| format!("{}: {e}", path.display()))?;
+        Self::parse(&src).map_err(|e| format!("{}: {e}", path.display()))
+    }
+
+    fn validate(&self) -> Result<(), String> {
+        validate_plugin_id(&self.id)?;
+        if self.name.trim().is_empty() {
+            return Err("`name` must not be empty".into());
+        }
+        if semver::Version::parse(&self.version).is_err() {
+            return Err(format!("`version` must be a semantic version like 1.2.3, got {:?}", self.version));
+        }
+        if !engine_compatible(&self.engine, self.legacy) {
+            return Err(if self.legacy {
+                format!(
+                    "unsupported openidea-api {:?} (this IDE implements {LEGACY_API} and {ENGINE_VERSION})",
+                    self.engine
+                )
+            } else {
+                format!("engines.openidea {:?} does not match this IDE's plugin API {ENGINE_VERSION}", self.engine)
+            });
+        }
+        if let Some(wasm) = &self.wasm {
+            check_relative(wasm, "wasm")?;
+        }
+        if self.wasm.is_none() && !self.activation.is_empty() {
+            return Err("`activation` needs `wasm`: there is no code to activate".into());
+        }
+        let mut seen = BTreeSet::new();
+        for event in &self.activation {
+            if !seen.insert(event) {
+                return Err(format!("duplicate activation event {event}"));
+            }
+        }
+        for c in &self.declared_categories {
+            validate_item_id(c, "category")?;
+        }
+        for (point, decls) in &self.contributes {
+            validate_point_id(point)?;
+            if !matches!(decls, toml::Value::Array(_) | toml::Value::Table(_)) {
+                return Err(format!("`contributes.{point}` must be a table or an array of tables"));
+            }
+        }
+        Ok(())
+    }
+
+    /// The declarations of one extension point: `[[contributes.x]]` gives
+    /// several, `[contributes.x]` one.
+    pub fn declarations(&self, point: &str) -> Vec<toml::Value> {
+        match self.contributes.get(point) {
+            Some(toml::Value::Array(items)) => items.clone(),
+            Some(single @ toml::Value::Table(_)) => vec![single.clone()],
+            _ => Vec::new(),
+        }
+    }
+
+    /// Number of declarations per extension point (for listings before loading).
+    pub fn declaration_counts(&self) -> Vec<(String, u32)> {
+        self.contributes.keys().map(|p| (p.clone(), self.declarations(p).len() as u32)).collect()
+    }
+
+    /// Publisher namespace: the id's part before the first `.` (`acme` in `acme.tools`).
+    pub fn publisher(&self) -> Option<&str> {
+        self.id.split_once('.').map(|(p, _)| p)
+    }
+
+    /// Whether `cap` is declared (required or optional).
+    pub fn declares(&self, cap: &Capability) -> bool {
+        self.capabilities.all().any(|c| c.covers(cap))
+    }
+}
+
+impl Manifest {
+    /// Its marketplace categories, in [`CATEGORIES`] order: the first
+    /// [`MAX_CATEGORIES`] declared that this IDE knows; without any, those its
+    /// contributions imply (themes, icon themes, languages), else `other`.
+    pub fn categories(&self) -> Vec<String> {
+        let pick = |f: &dyn Fn(&str) -> bool| CATEGORIES.iter().filter(|c| f(c)).map(|c| c.to_string()).collect();
+        let mut known: Vec<&str> = Vec::new();
+        for d in &self.declared_categories {
+            if CATEGORIES.contains(&d.as_str()) && !known.contains(&d.as_str()) && known.len() < MAX_CATEGORIES {
+                known.push(d);
+            }
+        }
+        let mut out: Vec<String> = pick(&|c| known.contains(&c));
+        if out.is_empty() {
+            out = pick(&|c| match c {
+                "themes" => self.contributes.contains_key("themes"),
+                "icon-themes" => self.contributes.contains_key("iconThemes"),
+                "languages" => self.contributes.contains_key("languages"),
+                _ => false,
+            });
+        }
+        if out.is_empty() {
+            out.push("other".into());
+        }
+        out
+    }
+
+    /// Declared categories this IDE doesn't know (ignored).
+    pub fn unknown_categories(&self) -> Vec<&str> {
+        self.declared_categories.iter().map(String::as_str).filter(|c| !CATEGORIES.contains(c)).collect()
+    }
+}
+
+/// Whether this host can load a plugin written for `engine`.
+pub fn engine_compatible(engine: &str, legacy: bool) -> bool {
+    if legacy {
+        return engine == LEGACY_API || engine.strip_prefix(LEGACY_API).is_some_and(|rest| rest.starts_with('.'));
+    }
+    let Ok(req) = semver::VersionReq::parse(engine) else { return false };
+    let host = semver::Version::parse(ENGINE_VERSION).expect("valid engine version");
+    req.matches(&host)
+}
+
+/// Segments of `[a-z0-9][a-z0-9_-]*` joined by `.` (an optional publisher
+/// namespace first), at most 64 chars.
+pub fn validate_plugin_id(id: &str) -> Result<(), String> {
+    let ok = id.len() <= 64 && !id.is_empty() && id.split('.').all(segment_ok);
+    if ok {
+        Ok(())
+    } else {
+        Err(format!(
+            "invalid plugin id {id:?}: use a-z, 0-9, '-', '_' in '.'-separated parts (e.g. acme.tools), max 64"
+        ))
+    }
+}
+
+/// `[a-z0-9][a-z0-9._-]*`, at most 64 chars (commands, themes, views…).
+pub fn validate_item_id(id: &str, what: &str) -> Result<(), String> {
+    let ok_first = id.chars().next().is_some_and(|c| c.is_ascii_lowercase() || c.is_ascii_digit());
+    let ok_rest = id.chars().all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || matches!(c, '-' | '_' | '.'));
+    if ok_first && ok_rest && id.len() <= 64 {
+        Ok(())
+    } else {
+        Err(format!("invalid {what} {id:?}: use a-z, 0-9, '.', '-', '_', starting with a letter or digit (max 64)"))
+    }
+}
+
+/// Extension point ids: `camelCase` or `kebab-case` words, dots allowed (`iconThemes`, `menus`).
+pub fn validate_point_id(id: &str) -> Result<(), String> {
+    let ok = !id.is_empty()
+        && id.len() <= 64
+        && id.starts_with(|c: char| c.is_ascii_lowercase())
+        && id.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '-' | '.'));
+    if ok { Ok(()) } else { Err(format!("invalid contribution point {id:?}")) }
+}
+
+fn segment_ok(s: &str) -> bool {
+    s.chars().next().is_some_and(|c| c.is_ascii_lowercase() || c.is_ascii_digit())
+        && s.chars().all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '-' || c == '_')
+}
+
+/// Package paths must stay inside the package directory.
+pub fn check_relative(path: &Path, what: &str) -> Result<(), String> {
+    let ok = !path.as_os_str().is_empty() && path.components().all(|c| matches!(c, Component::Normal(_)));
+    if ok { Ok(()) } else { Err(format!("{what} {:?} must be a relative path inside the plugin", path.display())) }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const FULL: &str = r#"
+        id = "acme.rust-tools"
+        name = "Rust Tools"
+        version = "1.2.0"
+        engines.openidea = "^1.0"
+        wasm = "plugin.wasm"
+        activation = ["on-language:rust", "on-command:check", "on-schedule:300"]
+
+        [capabilities]
+        required = ["project.read", "editor.write"]
+        optional = ["net:crates.io", "process:cargo"]
+
+        [[contributes.commands]]
+        id = "check"
+        title = "%check.title%"
+
+        [[contributes.menus]]
+        menu = "editor.context"
+        command = "check"
+        when = "editorLang == rust"
+
+        [contributes.settings]
+        schema = "settings.schema.json"
+    "#;
+
+    #[test]
+    fn event_activation() {
+        assert_eq!(ActivationEvent::parse("on-event:file-saved"), Ok(ActivationEvent::Event("file-saved".into())));
+        assert_eq!(ActivationEvent::Event("vcs-changed".into()).to_string(), "on-event:vcs-changed");
+        let err = ActivationEvent::parse("on-event:keystroke").unwrap_err();
+        assert!(err.contains("unknown event kind") && err.contains("action-performed"), "{err}");
+        assert!(ActivationEvent::parse("on-event:scheduled").is_err(), "declared with on-schedule");
+    }
+
+    #[test]
+    fn categories_are_declared_or_implied() {
+        let head = "id = \"acme.x\"\nname = \"X\"\nversion = \"1.0.0\"\nengines.openidea = \"^1.0\"\n";
+        let m = |rest: &str| Manifest::parse(&format!("{head}{rest}"));
+        // Declared, in the catalogue's order; unknown ones (a newer IDE's) are ignored.
+        let declared = m("categories = [\"tools\", \"vcs\", \"robots\"]\n").unwrap();
+        assert_eq!(declared.categories(), ["vcs", "tools"]);
+        assert_eq!(declared.unknown_categories(), ["robots"]);
+        // None declared: implied by the contributions, else `other`.
+        let theme = m("[[contributes.themes]]\nid = \"t\"\n[[contributes.languages]]\nid = \"l\"\n").unwrap();
+        assert_eq!(theme.categories(), ["languages", "themes"]);
+        let declared_wins = m("categories = [\"tools\"]\n[[contributes.languages]]\nid = \"l\"\n").unwrap();
+        assert_eq!(declared_wins.categories(), ["tools"]);
+        assert_eq!(m("").unwrap().categories(), ["other"]);
+        // At most three: the first ones declared.
+        let many = m("categories = [\"vcs\", \"ai\", \"vcs\", \"tools\", \"themes\"]\n").unwrap();
+        assert_eq!(many.categories(), ["vcs", "ai", "tools"]);
+        assert!(m("categories = [\"Bad Name\"]\n").is_err());
+    }
+
+    #[test]
+    fn parses_the_02_format() {
+        let m = Manifest::parse(FULL).unwrap();
+        assert_eq!(m.publisher(), Some("acme"));
+        assert!(!m.legacy);
+        assert_eq!(m.activation.len(), 3);
+        assert_eq!(m.activation[2], ActivationEvent::Schedule(300));
+        assert_eq!(m.capabilities.required, vec![Capability::ProjectRead, Capability::EditorWrite]);
+        assert!(m.capabilities.is_optional(&Capability::Process("cargo".into())));
+        assert_eq!(m.declarations("commands").len(), 1);
+        assert_eq!(m.declarations("settings").len(), 1, "a single table is one declaration");
+        assert!(m.declarations("nope").is_empty());
+        let counts: Vec<_> = m.declaration_counts();
+        assert!(counts.contains(&("menus".into(), 1)));
+    }
+
+    #[test]
+    fn parses_the_01_format() {
+        let m = Manifest::parse(
+            "id = \"hello\"\nname = \"Hello\"\nversion = \"0.1.0\"\nopenidea-api = \"0.1\"\nwasm = \"dist/plugin.wasm\"\n\
+             permissions = [\"project-read\", \"editor-write\"]\n[[contributes.commands]]\nid = \"x\"\ntitle = \"X\"",
+        )
+        .unwrap();
+        assert!(m.legacy);
+        assert_eq!(m.capabilities.required, vec![Capability::ProjectRead, Capability::EditorWrite]);
+        assert_eq!(m.activation, vec![ActivationEvent::StartupFinished]);
+        assert_eq!(m.publisher(), None);
+    }
+
+    fn err(src: &str) -> String {
+        Manifest::parse(src).unwrap_err()
+    }
+
+    #[test]
+    fn rejects_invalid_manifests() {
+        let base = |extra: &str| format!("id = \"ok\"\nname = \"N\"\nversion = \"1.0.0\"\n{extra}");
+        assert!(err(&base("")).contains("engines.openidea"));
+        assert!(err(&base("engines.openidea = \"^0.3\"")).contains("does not match"));
+        assert!(err(&base("engines.openidea = \"^2\"")).contains("does not match"));
+        assert!(err(&base("engines.openidea = \"^0.2\"")).contains("does not match"));
+        assert!(err(&base("openidea-api = \"0.2\"")).contains("unsupported"));
+        assert!(err(&base("engines.openidea = \"^1.0\"\npermissions = [\"project-read\"]")).contains("0.1 format"));
+        assert!(
+            err(&base("engines.openidea = \"^1.0\"\n[capabilities]\nrequired = [\"network\"]")).contains("unknown")
+        );
+        assert!(err(&base("engines.openidea = \"^1.0\"\nwasm = \"../x.wasm\"")).contains("relative path"));
+        assert!(err(&base("engines.openidea = \"^1.0\"\nactivation = [\"on-command:x\"]")).contains("needs `wasm`"));
+        assert!(
+            err(&base("engines.openidea = \"^1.0\"\nwasm = \"p.wasm\"\nactivation = [\"on-boot\"]"))
+                .contains("unknown")
+        );
+        assert!(
+            err(&base("engines.openidea = \"^1.0\"\nwasm = \"p.wasm\"\nactivation = [\"on-schedule:5\"]"))
+                .contains("60 seconds")
+        );
+        assert!(err(&base("engines.openidea = \"^1.0\"\nbogus = 1")).contains("unknown field"));
+        assert!(err(&base("engines.openidea = \"^1.0\"\ncontributes.commands = 3")).contains("table"));
+        assert!(
+            err("id = \"Bad\"\nname = \"N\"\nversion = \"1.0.0\"\nengines.openidea = \"^1.0\"").contains("plugin id")
+        );
+        assert!(
+            err("id = \"a..b\"\nname = \"N\"\nversion = \"1.0.0\"\nengines.openidea = \"^1.0\"").contains("plugin id")
+        );
+        assert!(err("id = \"ok\"\nname = \"N\"\nversion = \"1.0\"\nengines.openidea = \"^1.0\"").contains("version"));
+    }
+
+    #[test]
+    fn ids() {
+        assert!(validate_plugin_id("openidea.material-icons").is_ok());
+        assert!(validate_plugin_id("hello_2").is_ok());
+        assert!(validate_plugin_id(".x").is_err());
+        assert!(validate_item_id("word-count.v2_x", "command id").is_ok());
+        assert!(validate_item_id("-x", "command id").is_err());
+        assert!(validate_point_id("iconThemes").is_ok());
+        assert!(validate_point_id("Icon").is_err());
+        assert!(engine_compatible("1.0", false));
+        assert!(engine_compatible(">=1.0, <2", false));
+        assert!(!engine_compatible("^0.2", false), "0.x components don't run on 1.0");
+        assert!(engine_compatible("0.1.3", true));
+        assert!(!engine_compatible("0.10", true));
+    }
+}

crates/ide-extension/src/package.rs

@@ -0,0 +1,955 @@
+//! Plugin distribution: the package file, its
+//! signature, and the static marketplace index.
+//!
+//! - **Package** (`<id>-<version>.oiplugin`): a zip of the manifest, the files
+//!   its declarations reference, the component and licence files, plus
+//!   [`SIGNATURE_FILE`] when signed.
+//! - **Signature**: Ed25519 over `openidea-plugin/1\n<id>\n<version>\n<digest>`,
+//!   `digest` being [`package_digest`] of the unpacked files. A signature
+//!   proves who published the bytes; whether to trust that publisher is the
+//!   index's call.
+//! - **Index** (`index.json`): the publishers and their keys (the trust root),
+//!   the published plugin versions, and revocations. A publisher owns the id
+//!   prefix `<publisher>.`; a revoked key invalidates everything it signed, a
+//!   revoked plugin version is disabled where it is installed. A plugin may be
+//!   listed in several versions, each with the plugin API it needs: the IDE
+//!   offers the newest one it can load.
+//! - **Key continuity**: an installed plugin updates silently only to a
+//!   package signed with the same key, or with a key the installed one
+//!   endorsed ([`Endorsement`], a publisher rotating keys); any other signer
+//!   is the user's call. An IDE can pin a publisher to keys it was built with
+//!   ([`Index::pin_publisher`]): the index then can't replace them.
+//! - **Format**: fields are only ever added (IDEs ignore those they don't
+//!   know); `format` grows only for changes older IDEs can't read, and they
+//!   still apply such an index's revocations ([`Index::parse`]).
+
+use crate::MANIFEST_FILE;
+use base64::Engine as _;
+use ed25519_dalek::{Signature, Signer, SigningKey, VerifyingKey};
+use serde::{Deserialize, Serialize};
+use std::io::{Read, Write};
+use std::path::{Component, Path, PathBuf};
+
+pub const SIGNATURE_FILE: &str = "SIGNATURE.json";
+pub const PACKAGE_EXTENSION: &str = "oiplugin";
+pub const INDEX_FORMAT: u32 = 1;
+/// Limits when unpacking an untrusted package.
+const MAX_ENTRIES: usize = 10_000;
+const MAX_TOTAL: u64 = 512 << 20;
+
+const B64: base64::engine::GeneralPurpose = base64::engine::general_purpose::STANDARD;
+
+/// Content digest of a package: the manifest plus `files` (relative paths).
+pub fn package_digest(dir: &Path, files: &[PathBuf]) -> std::io::Result<String> {
+    let mut all = files.to_vec();
+    all.push(PathBuf::from(MANIFEST_FILE));
+    crate::ledger::package_hash(dir, &all)
+}
+
+fn signed_message(id: &str, version: &str, digest: &str) -> Vec<u8> {
+    format!("openidea-plugin/1\n{id}\n{version}\n{digest}").into_bytes()
+}
+
+fn endorsement_message(publisher: &str, key: &str) -> Vec<u8> {
+    format!("openidea-key/1\n{publisher}\n{key}").into_bytes()
+}
+
+/// Whether `signature` (base64) is `key`'s (base64) Ed25519 signature of
+/// `message`; malformed keys and signatures are errors.
+fn verify_ed25519(key: &str, message: &[u8], signature: &str) -> Result<bool, String> {
+    let key: [u8; 32] = B64
+        .decode(key)
+        .ok()
+        .and_then(|b| b.try_into().ok())
+        .ok_or_else(|| "signature: malformed public key".to_owned())?;
+    let key = VerifyingKey::from_bytes(&key).map_err(|_| "signature: invalid public key".to_owned())?;
+    let sig: [u8; 64] =
+        B64.decode(signature).ok().and_then(|b| b.try_into().ok()).ok_or_else(|| "signature: malformed".to_owned())?;
+    Ok(key.verify_strict(message, &Signature::from_bytes(&sig)).is_ok())
+}
+
+/// `SIGNATURE.json` of a signed package.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PackageSignature {
+    pub publisher: String,
+    /// Ed25519 public key, base64.
+    pub key: String,
+    /// Ed25519 signature, base64.
+    pub signature: String,
+}
+
+/// A publisher's key pair (the 32-byte seed, base64, in a file only the publisher has).
+pub struct PublisherKey(SigningKey);
+
+impl PublisherKey {
+    pub fn from_seed(seed: [u8; 32]) -> Self {
+        Self(SigningKey::from_bytes(&seed))
+    }
+
+    /// The seed as written by `openidea-plugin keygen`.
+    pub fn from_base64(text: &str) -> Result<Self, String> {
+        let bytes = B64.decode(text.trim()).map_err(|e| format!("key file: {e}"))?;
+        let seed: [u8; 32] = bytes.try_into().map_err(|_| "key file: expected a 32-byte key".to_owned())?;
+        Ok(Self::from_seed(seed))
+    }
+
+    pub fn seed_base64(&self) -> String {
+        B64.encode(self.0.to_bytes())
+    }
+
+    pub fn public_base64(&self) -> String {
+        B64.encode(self.0.verifying_key().to_bytes())
+    }
+
+    /// Vouches for `publisher`'s new key `key` (base64), the one that follows this one.
+    pub fn endorse(&self, publisher: &str, key: &str) -> Endorsement {
+        let sig = self.0.sign(&endorsement_message(publisher, key));
+        Endorsement { key: self.public_base64(), signature: B64.encode(sig.to_bytes()) }
+    }
+
+    pub fn sign(&self, publisher: &str, id: &str, version: &str, digest: &str) -> PackageSignature {
+        let sig = self.0.sign(&signed_message(id, version, digest));
+        PackageSignature {
+            publisher: publisher.into(),
+            key: self.public_base64(),
+            signature: B64.encode(sig.to_bytes()),
+        }
+    }
+}
+
+impl PackageSignature {
+    /// Whether the signature is valid for `id`, `version` and `digest` (the
+    /// key's validity is checked against an [`Index`]).
+    pub fn check(&self, id: &str, version: &str, digest: &str) -> Result<(), String> {
+        if verify_ed25519(&self.key, &signed_message(id, version, digest), &self.signature)? {
+            Ok(())
+        } else {
+            Err("the signature does not match the package (it was changed after signing)".to_owned())
+        }
+    }
+}
+
+/// Writes the package `out` from `dir`: the manifest, `files`, and the signature if any.
+pub fn pack(dir: &Path, files: &[PathBuf], out: &Path, signature: Option<&PackageSignature>) -> Result<(), String> {
+    let io = |e: std::io::Error| e.to_string();
+    let file = std::fs::File::create(out).map_err(io)?;
+    let mut zip = zip::ZipWriter::new(file);
+    let options = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Deflated);
+    let mut names: Vec<PathBuf> = std::iter::once(PathBuf::from(MANIFEST_FILE)).chain(files.iter().cloned()).collect();
+    names.sort();
+    names.dedup();
+    for rel in names {
+        let name = rel.to_str().ok_or("non UTF-8 file name")?.replace('\\', "/");
+        zip.start_file(name, options).map_err(|e| e.to_string())?;
+        let bytes = std::fs::read(dir.join(&rel)).map_err(|e| format!("{}: {e}", rel.display()))?;
+        zip.write_all(&bytes).map_err(io)?;
+    }
+    if let Some(sig) = signature {
+        zip.start_file(SIGNATURE_FILE, options).map_err(|e| e.to_string())?;
+        zip.write_all(serde_json::to_string_pretty(sig).map_err(|e| e.to_string())?.as_bytes()).map_err(io)?;
+    }
+    zip.finish().map_err(|e| e.to_string())?;
+    Ok(())
+}
+
+/// What [`unpack`] wrote.
+#[derive(Debug)]
+pub struct Unpacked {
+    /// Every file but the manifest and the signature, relative.
+    pub files: Vec<PathBuf>,
+    pub signature: Option<PackageSignature>,
+}
+
+/// `name` as a relative path that stays inside the package.
+fn safe_path(name: &str) -> Option<PathBuf> {
+    let p = Path::new(name);
+    (!name.is_empty() && p.components().all(|c| matches!(c, Component::Normal(_)))).then(|| p.to_path_buf())
+}
+
+/// Archiver metadata at the top of an archive, not part of a package
+/// (`__MACOSX/…`, `.DS_Store`, AppleDouble `._…` files).
+fn archiver_metadata(name: &str) -> bool {
+    let top = name.split('/').next().unwrap_or_default();
+    top == "__MACOSX" || top == ".DS_Store" || (top.starts_with("._") && top.len() > 2)
+}
+
+/// Where the package is inside an archive: at its root (`.oiplugin`, or a zip
+/// of the package's contents) or in its only folder (a zip of the package
+/// folder). `None` when neither holds a manifest.
+fn package_prefix(names: &[String]) -> Option<String> {
+    if names.iter().any(|n| n == MANIFEST_FILE) {
+        return Some(String::new());
+    }
+    let mut tops = names.iter().filter(|n| !archiver_metadata(n)).map(|n| n.split('/').next().unwrap_or_default());
+    let top = tops.next()?;
+    if tops.any(|t| t != top) {
+        return None;
+    }
+    let prefix = format!("{top}/");
+    names.iter().any(|n| *n == format!("{prefix}{MANIFEST_FILE}")).then_some(prefix)
+}
+
+/// Extracts the package `archive` (an `.oiplugin`, or a `.zip` of a package
+/// folder or of its contents) into the empty directory `dest`, refusing
+/// paths leaving it, links, and oversized contents.
+pub fn unpack(archive: &Path, dest: &Path) -> Result<Unpacked, String> {
+    let file = std::fs::File::open(archive).map_err(|e| format!("{}: {e}", archive.display()))?;
+    let mut zip =
+        zip::ZipArchive::new(file).map_err(|e| format!("{}: not a plugin package ({e})", archive.display()))?;
+    if zip.len() > MAX_ENTRIES {
+        return Err(format!("more than {MAX_ENTRIES} files"));
+    }
+    let mut names = Vec::with_capacity(zip.len());
+    for i in 0..zip.len() {
+        let entry = zip.by_index(i).map_err(|e| e.to_string())?;
+        if !entry.is_dir() {
+            names.push(entry.name().map_err(|e| e.to_string())?.into_owned());
+        }
+    }
+    // An IntelliJ plugin or any other zip: say what is missing rather than fail later.
+    let prefix = package_prefix(&names).ok_or_else(|| {
+        format!("{} is not an OpenIDEA plugin: no {MANIFEST_FILE} at its root or in its only folder", archive.display())
+    })?;
+    std::fs::create_dir_all(dest).map_err(|e| e.to_string())?;
+    let (mut files, mut signature, mut total, mut manifest) = (Vec::new(), None, 0u64, false);
+    for i in 0..zip.len() {
+        let mut entry = zip.by_index(i).map_err(|e| e.to_string())?;
+        if entry.is_dir() {
+            continue;
+        }
+        let full = entry.name().map_err(|e| e.to_string())?.into_owned();
+        // Outside the package folder there is only archiver metadata (`package_prefix` checked).
+        let Some(name) = full.strip_prefix(&prefix).map(str::to_owned) else { continue };
+        if archiver_metadata(&name) {
+            continue;
+        }
+        if entry.is_symlink() {
+            return Err(format!("{full}: links are not allowed in packages"));
+        }
+        let rel = safe_path(&name).ok_or_else(|| format!("invalid path {full:?} in package"))?;
+        let mut bytes = Vec::new();
+        entry.by_ref().take(MAX_TOTAL - total + 1).read_to_end(&mut bytes).map_err(|e| e.to_string())?;
+        total += bytes.len() as u64;
+        if total > MAX_TOTAL {
+            return Err(format!("the package unpacks to more than {} MiB", MAX_TOTAL >> 20));
+        }
+        if rel == Path::new(SIGNATURE_FILE) {
+            signature = Some(serde_json::from_slice(&bytes).map_err(|e| format!("{SIGNATURE_FILE}: {e}"))?);
+            continue;
+        }
+        let to = dest.join(&rel);
+        if let Some(parent) = to.parent() {
+            std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
+        }
+        std::fs::write(&to, bytes).map_err(|e| e.to_string())?;
+        if rel == Path::new(MANIFEST_FILE) {
+            manifest = true;
+        } else {
+            files.push(rel);
+        }
+    }
+    if !manifest {
+        return Err(format!("the package has no {MANIFEST_FILE}"));
+    }
+    files.sort();
+    Ok(Unpacked { files, signature })
+}
+
+// ---- index -------------------------------------------------------------------
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, specta::Type)]
+#[serde(rename_all = "camelCase")]
+pub struct Index {
+    pub format: u32,
+    #[serde(default)]
+    pub publishers: Vec<Publisher>,
+    #[serde(default)]
+    pub plugins: Vec<IndexEntry>,
+    #[serde(default)]
+    pub revoked: Vec<Revocation>,
+    /// The marketplace moved: its index is at this URL (relative to this
+    /// one, or absolute), and the IDE reads that one instead.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub moved: Option<String>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, specta::Type)]
+#[serde(rename_all = "camelCase")]
+pub struct Publisher {
+    /// Owns plugin ids `<id>.…`.
+    pub id: String,
+    pub name: String,
+    pub keys: Vec<KeyEntry>,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, specta::Type)]
+#[serde(rename_all = "camelCase")]
+pub struct KeyEntry {
+    /// Ed25519 public key, base64.
+    pub key: String,
+    /// Packages signed with it are no longer trusted.
+    #[serde(default)]
+    pub revoked: bool,
+    /// The publisher's earlier key vouching for this one.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub endorsement: Option<Endorsement>,
+}
+
+impl KeyEntry {
+    pub fn new(key: String) -> Self {
+        Self { key, ..Self::default() }
+    }
+}
+
+/// A publisher's earlier key vouching for a newer one: plugins installed from
+/// packages signed with the earlier key update to ones signed with the newer
+/// key without asking the user.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, specta::Type)]
+#[serde(rename_all = "camelCase")]
+pub struct Endorsement {
+    /// The endorsing key, base64.
+    pub key: String,
+    /// Its Ed25519 signature of `openidea-key/1\n<publisher>\n<endorsed key>`, base64.
+    pub signature: String,
+}
+
+/// A published plugin version.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, specta::Type)]
+#[serde(rename_all = "camelCase")]
+pub struct IndexEntry {
+    pub id: String,
+    pub name: String,
+    pub version: String,
+    #[serde(default)]
+    pub description: String,
+    #[serde(default)]
+    pub authors: Vec<String>,
+    pub publisher: String,
+    /// The package, relative to the index (or an absolute URL).
+    pub download: String,
+    /// [`package_digest`] of its contents.
+    pub digest: String,
+    #[serde(default)]
+    pub capabilities: Vec<String>,
+    /// The plugin API versions it loads in (a semver requirement): its
+    /// manifest's `engines.openidea` and the API its component was built for.
+    /// Required: an entry without one is offered to no IDE.
+    #[serde(default)]
+    pub engine: String,
+    /// Marketplace categories (`CATEGORIES`); an IDE ignores those it doesn't know.
+    #[serde(default)]
+    pub categories: Vec<String>,
+}
+
+impl IndexEntry {
+    /// Whether this IDE can load the version.
+    pub fn compatible(&self) -> bool {
+        crate::engine_compatible(&self.engine, false)
+    }
+
+    fn semver(&self) -> Option<semver::Version> {
+        semver::Version::parse(&self.version).ok()
+    }
+}
+
+/// `engines.openidea` of a manifest narrowed to the API its component was built
+/// for (`major.minor`, if it has code): the requirement an index lists.
+pub fn engine_requirement(manifest_engine: &str, built_for: Option<&semver::Version>) -> String {
+    match built_for {
+        Some(v) => format!("{manifest_engine}, ^{}.{}", v.major, v.minor),
+        None => manifest_engine.to_owned(),
+    }
+}
+
+/// A plugin (all versions when `versions` is empty) that must not run.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, specta::Type)]
+#[serde(rename_all = "camelCase")]
+pub struct Revocation {
+    pub id: String,
+    #[serde(default)]
+    pub versions: Vec<String>,
+    pub reason: String,
+}
+
+impl Index {
+    /// Parses an index. One in a newer format keeps what must reach every IDE —
+    /// revocations, publisher keys (revoked ones) and `moved` — and lists no
+    /// plugins ([`Index::is_newer`]): the IDE needs updating to install from it.
+    pub fn parse(text: &str) -> Result<Self, String> {
+        let value: serde_json::Value = serde_json::from_str(text).map_err(|e| format!("index: {e}"))?;
+        let format = value.get("format").and_then(serde_json::Value::as_u64).ok_or("index: `format` is missing")?;
+        if format == u64::from(INDEX_FORMAT) {
+            return serde_json::from_value(value).map_err(|e| format!("index: {e}"));
+        }
+        if format < u64::from(INDEX_FORMAT) {
+            return Err(format!("index format {format} is not supported (this IDE reads {INDEX_FORMAT})"));
+        }
+        fn each<T: serde::de::DeserializeOwned>(value: &serde_json::Value, field: &str) -> Vec<T> {
+            let items = value.get(field).and_then(serde_json::Value::as_array);
+            items.into_iter().flatten().filter_map(|v| serde_json::from_value(v.clone()).ok()).collect()
+        }
+        Ok(Index {
+            format: u32::try_from(format).unwrap_or(u32::MAX),
+            publishers: each(&value, "publishers"),
+            plugins: Vec::new(),
+            revoked: each(&value, "revoked"),
+            moved: value.get("moved").and_then(serde_json::Value::as_str).map(str::to_owned),
+        })
+    }
+
+    /// Written in a format newer than this IDE reads: it lists no plugins.
+    pub fn is_newer(&self) -> bool {
+        self.format > INDEX_FORMAT
+    }
+
+    /// The version of each plugin to offer, and whether this IDE can load it:
+    /// the newest it can load, else the newest. Revoked versions are skipped;
+    /// plugins come in the order they are first listed.
+    pub fn offered(&self) -> Vec<(&IndexEntry, bool)> {
+        let mut ids: Vec<&str> = Vec::new();
+        for e in &self.plugins {
+            if !ids.contains(&e.id.as_str()) {
+                ids.push(&e.id);
+            }
+        }
+        ids.into_iter()
+            .filter_map(|id| {
+                let versions: Vec<&IndexEntry> =
+                    self.plugins.iter().filter(|e| e.id == id && self.revocation(id, &e.version).is_none()).collect();
+                let newest = |loadable: bool| {
+                    versions.iter().copied().filter(|e| !loadable || e.compatible()).max_by_key(|e| e.semver())
+                };
+                newest(true).map(|e| (e, true)).or_else(|| newest(false).map(|e| (e, false)))
+            })
+            .collect()
+    }
+
+    /// Drops the versions no IDE would pick: revoked ones, and of each plugin
+    /// all but the newest version per API requirement.
+    pub fn prune_versions(&mut self) {
+        let plugins = std::mem::take(&mut self.plugins);
+        let mut kept: Vec<IndexEntry> = Vec::new();
+        for e in plugins.into_iter().filter(|e| self.revocation(&e.id, &e.version).is_none()) {
+            match kept.iter_mut().find(|k| k.id == e.id && k.engine == e.engine) {
+                Some(k) if e.semver() > k.semver() => *k = e,
+                Some(_) => {}
+                None => kept.push(e),
+            }
+        }
+        self.plugins = kept;
+    }
+
+    /// The revocation that applies to `id` at `version`.
+    pub fn revocation(&self, id: &str, version: &str) -> Option<&Revocation> {
+        self.revoked.iter().find(|r| r.id == id && (r.versions.is_empty() || r.versions.iter().any(|v| v == version)))
+    }
+
+    /// Whether `key` (base64) belongs to a publisher and was revoked.
+    pub fn key_revoked(&self, key: &str) -> bool {
+        self.publishers.iter().flat_map(|p| &p.keys).any(|k| k.key == key && k.revoked)
+    }
+
+    /// The trusted publisher of a signed package: the signature is valid, its
+    /// key is one of the publisher's and not revoked, and the publisher owns
+    /// the plugin's id prefix.
+    pub fn verify(&self, sig: &PackageSignature, id: &str, version: &str, digest: &str) -> Result<String, String> {
+        let publisher = self
+            .publishers
+            .iter()
+            .find(|p| p.id == sig.publisher)
+            .ok_or_else(|| format!("unknown publisher {:?}", sig.publisher))?;
+        let key = publisher
+            .keys
+            .iter()
+            .find(|k| k.key == sig.key)
+            .ok_or_else(|| format!("the key is not one of {}'s", publisher.name))?;
+        if key.revoked {
+            return Err(format!("{}'s signing key was revoked", publisher.name));
+        }
+        if !id.starts_with(&format!("{}.", publisher.id)) {
+            return Err(format!("{} may only publish plugins named {}.*", publisher.name, publisher.id));
+        }
+        sig.check(id, version, digest)?;
+        Ok(publisher.id.clone())
+    }
+
+    /// Whether `to` is `from`, or a key of `publisher` that `from` endorsed,
+    /// directly or through keys it endorsed. Endorsements by revoked keys don't
+    /// count: whoever stole a key could vouch for their own.
+    pub fn succeeds(&self, publisher: &str, from: &str, to: &str) -> bool {
+        let keys = self.publishers.iter().find(|p| p.id == publisher).map_or(&[][..], |p| &p.keys[..]);
+        let mut key = to;
+        // Each step moves to an earlier key; more steps than keys is a loop.
+        for _ in 0..=keys.len() {
+            if key == from {
+                return true;
+            }
+            let Some(e) = keys.iter().find(|k| k.key == key).and_then(|k| k.endorsement.as_ref()) else {
+                return false;
+            };
+            let endorser_valid = keys.iter().any(|k| k.key == e.key && !k.revoked);
+            if !endorser_valid || verify_ed25519(&e.key, &endorsement_message(publisher, key), &e.signature) != Ok(true)
+            {
+                return false;
+            }
+            key = &e.key;
+        }
+        false
+    }
+
+    /// Makes `roots` (base64) the keys `publisher` signs with, whatever this
+    /// index says: another key it lists stays only when a root endorsed it (a
+    /// rotation the roots vouched for). Revocations of the keys are kept.
+    pub fn pin_publisher(&mut self, publisher: &str, name: &str, roots: &[String]) {
+        if roots.is_empty() {
+            return;
+        }
+        let i = match self.publishers.iter().position(|p| p.id == publisher) {
+            Some(i) => i,
+            None => {
+                self.publishers.push(Publisher { id: publisher.into(), name: name.into(), keys: Vec::new() });
+                self.publishers.len() - 1
+            }
+        };
+        for root in roots {
+            if !self.publishers[i].keys.iter().any(|k| &k.key == root) {
+                self.publishers[i].keys.push(KeyEntry::new(root.clone()));
+            }
+        }
+        let keys = self.publishers[i].keys.clone();
+        let trusted = keys
+            .into_iter()
+            .filter(|k| roots.iter().any(|r| self.succeeds(publisher, r, &k.key)))
+            .map(|k| if roots.contains(&k.key) { KeyEntry { endorsement: None, ..k } } else { k })
+            .collect();
+        self.publishers[i].keys = trusted;
+    }
+
+    /// Replaces what this index lists for every publisher but `keep` with what
+    /// `other` lists: its publishers, their plugins and their revocations
+    /// (`other`'s downloads should already be absolute). `other` may only
+    /// speak for its own publishers, and none of them may be in `keep`.
+    pub fn include(&mut self, other: Index, keep: &[&str]) -> Result<(), String> {
+        let mut theirs: Vec<&str> = Vec::new();
+        for p in &other.publishers {
+            if !publisher_id_ok(&p.id) {
+                return Err(format!("invalid publisher id {:?}: use a-z, 0-9, '-' and '_'", p.id));
+            }
+            if keep.contains(&p.id.as_str()) {
+                return Err(format!("may not list publisher {:?}", p.id));
+            }
+            if theirs.contains(&p.id.as_str()) {
+                return Err(format!("publisher {:?} is listed twice", p.id));
+            }
+            theirs.push(&p.id);
+        }
+        let owned_by = |id: &str| theirs.iter().any(|p| owns(p, id));
+        for e in &other.plugins {
+            if !theirs.contains(&e.publisher.as_str()) || !owns(&e.publisher, &e.id) {
+                return Err(format!("{}: not a plugin of publisher {:?}", e.id, e.publisher));
+            }
+            if semver::VersionReq::parse(&e.engine).is_err() {
+                return Err(format!("{} {}: `engine` must be the plugin API it needs", e.id, e.version));
+            }
+        }
+        if let Some(r) = other.revoked.iter().find(|r| !owned_by(&r.id)) {
+            return Err(format!("{}: revoked by an index that doesn't publish it", r.id));
+        }
+        let kept = |id: &str| keep.iter().any(|p| owns(p, id));
+        self.publishers.retain(|p| keep.contains(&p.id.as_str()));
+        self.plugins.retain(|e| keep.contains(&e.publisher.as_str()));
+        self.revoked.retain(|r| kept(&r.id));
+        self.publishers.extend(other.publishers);
+        self.plugins.extend(other.plugins);
+        self.revoked.extend(other.revoked);
+        Ok(())
+    }
+}
+
+/// Whether a package signed `new` (`None`: unsigned) may replace an installed
+/// one signed `installed` without asking the user: signed with the same key,
+/// or with one the installed key endorsed (per `index`). An unsigned installed
+/// copy pins nothing.
+pub fn signer_continues(
+    index: Option<&Index>,
+    installed: Option<&PackageSignature>,
+    new: Option<&PackageSignature>,
+) -> bool {
+    match (installed, new) {
+        (None, _) => true,
+        (Some(_), None) => false,
+        (Some(old), Some(new)) => {
+            old.publisher == new.publisher
+                && (old.key == new.key || index.is_some_and(|i| i.succeeds(&new.publisher, &old.key, &new.key)))
+        }
+    }
+}
+
+/// Whether the plugin `id` is in `publisher`'s namespace.
+fn owns(publisher: &str, id: &str) -> bool {
+    id.strip_prefix(publisher).is_some_and(|rest| rest.starts_with('.'))
+}
+
+/// A publisher id is a single segment of a plugin id.
+pub fn publisher_id_ok(id: &str) -> bool {
+    !id.contains('.') && crate::validate_plugin_id(id).is_ok()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn package(dir: &Path) -> Vec<PathBuf> {
+        std::fs::create_dir_all(dir.join("dist")).unwrap();
+        std::fs::write(dir.join(MANIFEST_FILE), "id = \"acme.tools\"\nversion = \"1.0.0\"").unwrap();
+        std::fs::write(dir.join("dist/plugin.wasm"), b"\0asm").unwrap();
+        vec![PathBuf::from("dist/plugin.wasm")]
+    }
+
+    fn index(key: &PublisherKey) -> Index {
+        Index {
+            format: INDEX_FORMAT,
+            publishers: vec![Publisher {
+                id: "acme".into(),
+                name: "ACME".into(),
+                keys: vec![KeyEntry::new(key.public_base64())],
+            }],
+            plugins: Vec::new(),
+            revoked: vec![Revocation {
+                id: "acme.bad".into(),
+                versions: vec!["1.0.0".into()],
+                reason: "malware".into(),
+            }],
+            moved: None,
+        }
+    }
+
+    #[test]
+    fn signed_packages_round_trip_and_tampering_is_caught() {
+        let tmp = tempfile::tempdir().unwrap();
+        let src = tmp.path().join("src");
+        let files = package(&src);
+        let digest = package_digest(&src, &files).unwrap();
+        let key = PublisherKey::from_seed([7; 32]);
+        let sig = key.sign("acme", "acme.tools", "1.0.0", &digest);
+        let out = tmp.path().join("acme.tools-1.0.0.oiplugin");
+        pack(&src, &files, &out, Some(&sig)).unwrap();
+
+        let dest = tmp.path().join("dest");
+        let unpacked = unpack(&out, &dest).unwrap();
+        assert_eq!(unpacked.files, files);
+        assert_eq!(package_digest(&dest, &unpacked.files).unwrap(), digest);
+        let index = index(&key);
+        assert_eq!(index.verify(unpacked.signature.as_ref().unwrap(), "acme.tools", "1.0.0", &digest).unwrap(), "acme");
+
+        // Changed bytes, another id, someone else's prefix, a revoked key.
+        assert!(index.verify(&sig, "acme.tools", "1.0.0", "0000").is_err());
+        assert!(index.verify(&sig, "acme.tools", "1.0.1", &digest).is_err());
+        let other = PublisherKey::from_seed([9; 32]).sign("acme", "acme.tools", "1.0.0", &digest);
+        assert!(index.verify(&other, "acme.tools", "1.0.0", &digest).unwrap_err().contains("not one of"));
+        let foreign = key.sign("acme", "evil.tools", "1.0.0", &digest);
+        assert!(index.verify(&foreign, "evil.tools", "1.0.0", &digest).unwrap_err().contains("acme.*"));
+        let mut revoked = index.clone();
+        revoked.publishers[0].keys[0].revoked = true;
+        assert!(revoked.verify(&sig, "acme.tools", "1.0.0", &digest).unwrap_err().contains("revoked"));
+        assert!(revoked.key_revoked(&sig.key));
+        assert_eq!(index.revocation("acme.bad", "1.0.0").unwrap().reason, "malware");
+        assert!(index.revocation("acme.bad", "1.0.1").is_none());
+        assert_eq!(PublisherKey::from_base64(&key.seed_base64()).unwrap().public_base64(), key.public_base64());
+    }
+
+    fn entry(id: &str, publisher: &str) -> IndexEntry {
+        IndexEntry {
+            id: id.into(),
+            name: id.into(),
+            version: "1.0.0".into(),
+            description: String::new(),
+            authors: Vec::new(),
+            publisher: publisher.into(),
+            download: format!("https://example.com/{id}.oiplugin"),
+            digest: "d".into(),
+            capabilities: Vec::new(),
+            engine: "^1.0".into(),
+            categories: Vec::new(),
+        }
+    }
+
+    fn version(id: &str, version: &str, engine: &str) -> IndexEntry {
+        IndexEntry { version: version.into(), engine: engine.into(), ..entry(id, "acme") }
+    }
+
+    #[test]
+    fn the_ide_is_offered_the_newest_version_it_can_load() {
+        let host = crate::ENGINE_VERSION;
+        let newer = semver::Version::parse(host).unwrap().major + 1;
+        let mut index = Index {
+            format: INDEX_FORMAT,
+            plugins: vec![
+                version("acme.a", "1.0.0", &format!("^{host}")),
+                version("acme.a", "1.2.0", &format!("^{host}")),
+                version("acme.a", "2.0.0", &format!("^{newer}.0")),
+                version("acme.b", "0.1.0", &format!("^{newer}.0")),
+                version("acme.b", "0.2.0", &format!("^{newer}.1")),
+                version("acme.c", "1.0.0", ""),
+                version("acme.c", "1.1.0", ""),
+            ],
+            revoked: vec![Revocation { id: "acme.c".into(), versions: vec!["1.1.0".into()], reason: "r".into() }],
+            ..Index::default()
+        };
+        let offered = |index: &Index| {
+            index.offered().into_iter().map(|(e, ok)| (e.id.clone(), e.version.clone(), ok)).collect::<Vec<_>>()
+        };
+        let expected = [
+            ("acme.a".to_owned(), "1.2.0".to_owned(), true),
+            ("acme.b".to_owned(), "0.2.0".to_owned(), false),
+            // No `engine`: listed, but no IDE installs it.
+            ("acme.c".to_owned(), "1.0.0".to_owned(), false),
+        ];
+        assert_eq!(offered(&index), expected);
+
+        // Pruning keeps the newest version per requirement, which changes nothing offered.
+        index.prune_versions();
+        let left: Vec<_> = index.plugins.iter().map(|e| format!("{} {}", e.id, e.version)).collect();
+        assert_eq!(left, ["acme.a 1.2.0", "acme.a 2.0.0", "acme.b 0.1.0", "acme.b 0.2.0", "acme.c 1.0.0"]);
+        assert_eq!(offered(&index), expected);
+
+        let built_for = semver::Version::new(1, 3, 0);
+        assert_eq!(engine_requirement("^1.0", Some(&built_for)), "^1.0, ^1.3");
+        assert_eq!(engine_requirement("^1.0", None), "^1.0");
+        assert!(semver::VersionReq::parse(&engine_requirement("^1.0", Some(&built_for))).is_ok());
+    }
+
+    fn publisher(id: &str) -> Publisher {
+        Publisher { id: id.into(), name: id.into(), keys: vec![KeyEntry::new(format!("{id}-key"))] }
+    }
+
+    fn revocation(id: &str) -> Revocation {
+        Revocation { id: id.into(), versions: Vec::new(), reason: "r".into() }
+    }
+
+    #[test]
+    fn including_an_index_replaces_everything_but_the_kept_publishers() {
+        let mut official = Index {
+            format: INDEX_FORMAT,
+            publishers: vec![publisher("openidea"), publisher("gone")],
+            plugins: vec![entry("openidea.a", "openidea"), entry("gone.x", "gone")],
+            revoked: vec![revocation("openidea.old"), revocation("gone.x")],
+            moved: None,
+        };
+        let community = Index {
+            format: INDEX_FORMAT,
+            publishers: vec![publisher("alice")],
+            plugins: vec![entry("alice.arthas", "alice")],
+            revoked: vec![revocation("alice.bad")],
+            moved: None,
+        };
+        official.include(community.clone(), &["openidea"]).unwrap();
+        let ids = |v: &[IndexEntry]| v.iter().map(|e| e.id.clone()).collect::<Vec<_>>();
+        assert_eq!(official.publishers.iter().map(|p| p.id.as_str()).collect::<Vec<_>>(), ["openidea", "alice"]);
+        assert_eq!(ids(&official.plugins), ["openidea.a", "alice.arthas"]);
+        assert_eq!(official.revoked.iter().map(|r| r.id.as_str()).collect::<Vec<_>>(), ["openidea.old", "alice.bad"]);
+
+        // Including again is idempotent.
+        let once = official.clone();
+        official.include(community.clone(), &["openidea"]).unwrap();
+        assert_eq!(official, once);
+    }
+
+    #[test]
+    fn an_included_index_speaks_only_for_its_own_publishers() {
+        let base = Index { format: INDEX_FORMAT, publishers: vec![publisher("openidea")], ..Index::default() };
+        let with = |publishers: Vec<Publisher>, plugins: Vec<IndexEntry>, revoked: Vec<Revocation>| Index {
+            format: INDEX_FORMAT,
+            publishers,
+            plugins,
+            revoked,
+            moved: None,
+        };
+        let cases = [
+            (with(vec![publisher("openidea")], vec![], vec![]), "may not list"),
+            (with(vec![publisher("alice"), publisher("alice")], vec![], vec![]), "listed twice"),
+            (with(vec![publisher("openidea.x")], vec![], vec![]), "invalid publisher"),
+            (with(vec![publisher("alice")], vec![entry("openidea.a", "alice")], vec![]), "not a plugin of"),
+            (with(vec![publisher("alice")], vec![entry("alice.a", "bob")], vec![]), "not a plugin of"),
+            (with(vec![publisher("alice")], vec![entry("alicex.a", "alice")], vec![]), "not a plugin of"),
+            (with(vec![publisher("alice")], vec![], vec![revocation("openidea.a")]), "doesn't publish"),
+            (
+                with(
+                    vec![publisher("alice")],
+                    vec![IndexEntry { engine: String::new(), ..entry("alice.a", "alice") }],
+                    vec![],
+                ),
+                "`engine`",
+            ),
+        ];
+        for (other, error) in cases {
+            let mut index = base.clone();
+            let err = index.include(other, &["openidea"]).unwrap_err();
+            assert!(err.contains(error), "{err}");
+            assert_eq!(index, base);
+        }
+    }
+
+    #[test]
+    fn unpacking_refuses_paths_leaving_the_package() {
+        let tmp = tempfile::tempdir().unwrap();
+        let out = tmp.path().join("evil.oiplugin");
+        let mut zip = zip::ZipWriter::new(std::fs::File::create(&out).unwrap());
+        let o = zip::write::SimpleFileOptions::default();
+        zip.start_file(MANIFEST_FILE, o).unwrap();
+        zip.write_all(b"id = \"x\"").unwrap();
+        zip.start_file("../outside.txt", o).unwrap();
+        zip.write_all(b"x").unwrap();
+        zip.finish().unwrap();
+        let err = unpack(&out, &tmp.path().join("dest")).unwrap_err();
+        assert!(err.contains("invalid path"), "{err}");
+        assert!(!tmp.path().join("outside.txt").exists());
+        assert!(Index::parse(r#"{"format": 2}"#).unwrap().is_newer());
+    }
+
+    fn zip_of(path: &Path, entries: &[(&str, &str)]) {
+        let mut zip = zip::ZipWriter::new(std::fs::File::create(path).unwrap());
+        for (name, body) in entries {
+            zip.start_file(*name, zip::write::SimpleFileOptions::default()).unwrap();
+            zip.write_all(body.as_bytes()).unwrap();
+        }
+        zip.finish().unwrap();
+    }
+
+    #[test]
+    fn a_zip_holds_the_package_at_its_root_or_in_its_only_folder() {
+        let tmp = tempfile::tempdir().unwrap();
+        let manifest = "id = \"acme.tools\"";
+        let at_root = tmp.path().join("root.zip");
+        zip_of(&at_root, &[(MANIFEST_FILE, manifest), ("dist/plugin.wasm", "w"), (".DS_Store", "x")]);
+        let got = unpack(&at_root, &tmp.path().join("a")).unwrap();
+        assert_eq!(got.files, [PathBuf::from("dist/plugin.wasm")]);
+
+        // What zipping the folder in Finder makes: the folder plus `__MACOSX`.
+        let folder = tmp.path().join("folder.zip");
+        zip_of(
+            &folder,
+            &[
+                ("acme-tools/plugin.toml", manifest),
+                ("acme-tools/dist/plugin.wasm", "w"),
+                ("__MACOSX/acme-tools/._plugin.toml", "x"),
+            ],
+        );
+        let dest = tmp.path().join("b");
+        let got = unpack(&folder, &dest).unwrap();
+        assert_eq!(got.files, [PathBuf::from("dist/plugin.wasm")]);
+        assert!(dest.join(MANIFEST_FILE).is_file());
+        assert!(!dest.join("__MACOSX").exists() && !dest.join("acme-tools").exists());
+
+        // Two folders, a manifest one level too deep, or none (an IntelliJ plugin): not a package.
+        for (name, entries) in [
+            ("two.zip", &[("a/plugin.toml", manifest), ("b/x.txt", "x")][..]),
+            ("deep.zip", &[("a/b/plugin.toml", manifest)][..]),
+            ("intellij.zip", &[("my-plugin/lib/my-plugin.jar", "jar")][..]),
+        ] {
+            let path = tmp.path().join(name);
+            zip_of(&path, entries);
+            let err = unpack(&path, &tmp.path().join(name).with_extension("out")).unwrap_err();
+            assert!(err.contains("is not an OpenIDEA plugin"), "{name}: {err}");
+        }
+    }
+
+    #[test]
+    fn a_newer_index_still_revokes_and_moves() {
+        let newer = format!(
+            r#"{{"format": {}, "plugins": [{{"anything": "new"}}], "shape": "changed",
+                "publishers": [{{"id": "acme", "name": "ACME", "keys": [{{"key": "k1", "revoked": true}}]}}, {{"id": 5}}],
+                "revoked": [{{"id": "acme.bad", "reason": "malware"}}, {{"oops": 1}}],
+                "moved": "https://example.com/next.json"}}"#,
+            INDEX_FORMAT + 1
+        );
+        let index = Index::parse(&newer).unwrap();
+        assert!(index.is_newer());
+        assert!(index.plugins.is_empty() && index.offered().is_empty());
+        assert_eq!(index.revocation("acme.bad", "2.0.0").unwrap().reason, "malware");
+        assert!(index.key_revoked("k1"));
+        assert_eq!(index.moved.as_deref(), Some("https://example.com/next.json"));
+        // Fields this IDE doesn't know are ignored in its own format.
+        let current = format!(r#"{{"format": {INDEX_FORMAT}, "later": true, "plugins": []}}"#);
+        assert!(!Index::parse(&current).unwrap().is_newer());
+        assert!(Index::parse(r#"{"format": 0}"#).unwrap_err().contains("not supported"));
+        assert!(Index::parse(r#"{"plugins": []}"#).is_err());
+    }
+
+    fn keys<'a>(index: &'a mut Index, publisher: &str) -> &'a mut Vec<KeyEntry> {
+        &mut index.publishers.iter_mut().find(|p| p.id == publisher).unwrap().keys
+    }
+
+    #[test]
+    fn rotated_keys_continue_through_endorsements() {
+        let (k1, k2, k3) =
+            (PublisherKey::from_seed([1; 32]), PublisherKey::from_seed([2; 32]), PublisherKey::from_seed([3; 32]));
+        let mut index = index(&k1);
+        let endorsed = |by: &PublisherKey, key: &PublisherKey| KeyEntry {
+            endorsement: Some(by.endorse("acme", &key.public_base64())),
+            ..KeyEntry::new(key.public_base64())
+        };
+        keys(&mut index, "acme").push(endorsed(&k1, &k2));
+        keys(&mut index, "acme").push(endorsed(&k2, &k3));
+        let (p1, p2, p3) = (k1.public_base64(), k2.public_base64(), k3.public_base64());
+        assert!(index.succeeds("acme", &p1, &p1));
+        assert!(index.succeeds("acme", &p1, &p3), "through k2");
+        assert!(!index.succeeds("acme", &p3, &p1), "not backwards");
+        assert!(!index.succeeds("other", &p1, &p2));
+        // An endorsement for another publisher, or by a revoked key, doesn't count.
+        let mut foreign = index.clone();
+        keys(&mut foreign, "acme")[1].endorsement = Some(k1.endorse("evil", &p2));
+        assert!(!foreign.succeeds("acme", &p1, &p2));
+        let mut stolen = index.clone();
+        keys(&mut stolen, "acme")[0].revoked = true;
+        assert!(!stolen.succeeds("acme", &p1, &p2));
+
+        let sig = |key: &PublisherKey| key.sign("acme", "acme.tools", "1.0.0", "d");
+        assert!(signer_continues(Some(&index), Some(&sig(&k1)), Some(&sig(&k3))));
+        assert!(signer_continues(None, Some(&sig(&k1)), Some(&sig(&k1))));
+        assert!(!signer_continues(None, Some(&sig(&k1)), Some(&sig(&k2))), "no index to vouch");
+        let stranger = PublisherKey::from_seed([4; 32]);
+        assert!(!signer_continues(Some(&index), Some(&sig(&k1)), Some(&sig(&stranger))));
+        assert!(!signer_continues(Some(&index), Some(&sig(&k1)), None), "signed, then unsigned");
+        assert!(signer_continues(Some(&index), None, Some(&sig(&stranger))), "unsigned pins nothing");
+    }
+
+    #[test]
+    fn pinned_publishers_keep_their_built_in_keys() {
+        let (root, next, intruder) =
+            (PublisherKey::from_seed([1; 32]), PublisherKey::from_seed([2; 32]), PublisherKey::from_seed([5; 32]));
+        let mut index = index(&intruder);
+        index.publishers[0].id = "openidea".into();
+        keys(&mut index, "openidea").push(KeyEntry {
+            endorsement: Some(root.endorse("openidea", &next.public_base64())),
+            ..KeyEntry::new(next.public_base64())
+        });
+        let roots = [root.public_base64()];
+        let listed = |index: &Index| -> Vec<(String, bool)> {
+            let mut index = index.clone();
+            index.pin_publisher("openidea", "OpenIDEA", &roots);
+            keys(&mut index, "openidea").iter().map(|k| (k.key.clone(), k.revoked)).collect()
+        };
+        // The intruder's key goes, the successor the root endorsed stays, the root is added.
+        assert_eq!(listed(&index), [(next.public_base64(), false), (root.public_base64(), false)]);
+        let mut pinned = index.clone();
+        pinned.pin_publisher("openidea", "OpenIDEA", &roots);
+        let digest = "d";
+        let signed = |k: &PublisherKey| k.sign("openidea", "openidea.tools", "1.0.0", digest);
+        assert!(pinned.verify(&signed(&intruder), "openidea.tools", "1.0.0", digest).is_err());
+        assert!(pinned.verify(&signed(&next), "openidea.tools", "1.0.0", digest).is_ok());
+        // A revoked root stays revoked, and what it endorsed is no longer trusted.
+        keys(&mut index, "openidea").push(KeyEntry { revoked: true, ..KeyEntry::new(root.public_base64()) });
+        assert_eq!(listed(&index), [(root.public_base64(), true)]);
+
+        // A publisher missing from the index is added with its roots.
+        let mut empty = Index { format: INDEX_FORMAT, ..Index::default() };
+        empty.pin_publisher("openidea", "OpenIDEA", &[root.public_base64()]);
+        assert_eq!(empty.verify(&signed(&root), "openidea.tools", "1.0.0", digest).unwrap(), "openidea");
+        // No roots: the index decides.
+        let mut open = index.clone();
+        open.pin_publisher("openidea", "OpenIDEA", &[]);
+        assert_eq!(open, index);
+    }
+}

crates/ide-extension/src/point.rs

@@ -0,0 +1,175 @@
+//! The extension point contract (plan 4.1).
+
+use crate::capability::Capability;
+use crate::manifest::{Manifest, check_relative};
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+/// Where a contribution takes effect (plan 3, placement rules).
+#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize, specta::Type)]
+#[serde(rename_all = "camelCase")]
+pub enum Placement {
+    /// Projected to the client (menus, keybindings, themes, icons).
+    Ui,
+    /// Takes effect on the machine the project is on (languages, LSP, run configurations).
+    Workspace,
+}
+
+/// The package a declaration comes from, as extension points see it.
+#[derive(Clone, Debug)]
+pub struct Package {
+    pub manifest: Arc<Manifest>,
+    /// Package directory.
+    pub dir: PathBuf,
+    /// Hash of the package's files when they never change (an installed
+    /// copy): validated declarations are then reused from the
+    /// [`ContributionIndex`](crate::ContributionIndex).
+    pub digest: Option<Arc<str>>,
+}
+
+/// Largest single package file an extension point reads.
+pub const MAX_PACKAGE_FILE: u64 = 8 << 20;
+
+impl Package {
+    pub fn new(manifest: Manifest, dir: PathBuf) -> Self {
+        Self { manifest: Arc::new(manifest), dir, digest: None }
+    }
+
+    pub fn with_digest(mut self, digest: &str) -> Self {
+        self.digest = Some(digest.into());
+        self
+    }
+
+    pub fn id(&self) -> &str {
+        &self.manifest.id
+    }
+
+    /// Resolves a package-relative path, refusing anything that leaves the
+    /// package (`..`, absolute paths, symlinks pointing outside).
+    pub fn resolve(&self, rel: &Path) -> Result<PathBuf, String> {
+        check_relative(rel, "path")?;
+        let joined = self.dir.join(rel);
+        let real = joined.canonicalize().map_err(|_| format!("{}: no such file in the plugin", rel.display()))?;
+        let root = self.dir.canonicalize().map_err(|e| format!("plugin directory: {e}"))?;
+        if !real.starts_with(&root) {
+            return Err(format!("{}: points outside the plugin", rel.display()));
+        }
+        Ok(real)
+    }
+
+    pub fn read_bytes(&self, rel: &Path) -> Result<Vec<u8>, String> {
+        let real = self.resolve(rel)?;
+        let meta = std::fs::metadata(&real).map_err(|e| format!("{}: {e}", rel.display()))?;
+        if !meta.is_file() {
+            return Err(format!("{}: not a file", rel.display()));
+        }
+        if meta.len() > MAX_PACKAGE_FILE {
+            return Err(format!("{}: larger than {} MiB", rel.display(), MAX_PACKAGE_FILE >> 20));
+        }
+        std::fs::read(&real).map_err(|e| format!("{}: {e}", rel.display()))
+    }
+
+    pub fn read_text(&self, rel: &Path) -> Result<String, String> {
+        String::from_utf8(self.read_bytes(rel)?).map_err(|_| format!("{}: not UTF-8 text", rel.display()))
+    }
+}
+
+/// Undoes one committed contribution. Dropping without [`dispose`](Self::dispose) also disposes.
+#[must_use = "dropping a Disposable undoes the contribution"]
+pub struct Disposable(Option<Box<dyn FnOnce() + Send>>);
+
+impl Disposable {
+    pub fn new(f: impl FnOnce() + Send + 'static) -> Self {
+        Self(Some(Box::new(f)))
+    }
+
+    /// A contribution with nothing to undo.
+    pub fn noop() -> Self {
+        Self(None)
+    }
+
+    pub fn dispose(mut self) {
+        if let Some(f) = self.0.take() {
+            f();
+        }
+    }
+}
+
+impl Drop for Disposable {
+    fn drop(&mut self) {
+        if let Some(f) = self.0.take() {
+            f();
+        }
+    }
+}
+
+impl std::fmt::Debug for Disposable {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("Disposable")
+    }
+}
+
+pub type Commit = Box<dyn FnOnce() -> Result<Disposable, String> + Send>;
+
+/// A validated declaration, ready to take effect.
+pub struct Prepared {
+    /// Capabilities this declaration needs (a language with an LSP → `process:<binary>`).
+    pub capabilities: Vec<Capability>,
+    /// Package files the declaration references (copied on install).
+    pub files: Vec<PathBuf>,
+    /// Identity within the point: a later declaration with the same key replaces
+    /// the earlier one of the same plugin (re-registering a command).
+    pub key: Option<String>,
+    /// User-facing one-liner for the plugin details page ("Insert Date").
+    pub label: String,
+    /// Makes it take effect. Must not fail for reasons `prepare` could have checked.
+    pub commit: Commit,
+}
+
+impl Prepared {
+    pub fn new(label: impl Into<String>, commit: impl FnOnce() -> Result<Disposable, String> + Send + 'static) -> Self {
+        Self { capabilities: Vec::new(), files: Vec::new(), key: None, label: label.into(), commit: Box::new(commit) }
+    }
+
+    pub fn key(mut self, key: impl Into<String>) -> Self {
+        self.key = Some(key.into());
+        self
+    }
+
+    pub fn file(mut self, path: impl Into<PathBuf>) -> Self {
+        self.files.push(path.into());
+        self
+    }
+
+    pub fn capability(mut self, cap: Capability) -> Self {
+        if !self.capabilities.contains(&cap) {
+            self.capabilities.push(cap);
+        }
+        self
+    }
+}
+
+impl std::fmt::Debug for Prepared {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Prepared").field("key", &self.key).field("label", &self.label).finish_non_exhaustive()
+    }
+}
+
+/// A kind of contribution (`contributes.<id>` in the manifest). Implemented by
+/// the crate that owns the feature; registered once in an [`crate::ExtensionRegistry`].
+pub trait ExtensionPoint: Send + Sync {
+    /// `"languages"`, `"iconThemes"`, …
+    fn id(&self) -> &'static str;
+
+    fn placement(&self) -> Placement;
+
+    /// Parses and validates one declaration without side effects, and works
+    /// out the capabilities it needs. `Ui` points validate completely here: the
+    /// client's projection is not allowed to fail.
+    fn prepare(&self, pkg: &Package, decl: toml::Value) -> Result<Prepared, String>;
+}
+
+/// Deserializes a declaration with serde, prefixing errors with the point id.
+pub fn decode<T: serde::de::DeserializeOwned>(point: &str, decl: toml::Value) -> Result<T, String> {
+    decl.try_into().map_err(|e: toml::de::Error| format!("contributes.{point}: {}", e.message()))
+}

crates/ide-extension/src/registry.rs

@@ -0,0 +1,305 @@
+//! Extension points plus the contributions committed to them, accounted per plugin.
+
+use crate::capability::Capability;
+use crate::point::{Disposable, ExtensionPoint, Package, Placement, Prepared};
+use parking_lot::{Mutex, RwLock};
+use serde::{Deserialize, Serialize};
+use specta::Type;
+use std::collections::BTreeMap;
+use std::path::PathBuf;
+use std::sync::Arc;
+
+/// A contribution as the plugin details page lists it.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct ContributionInfo {
+    pub point: String,
+    pub label: String,
+}
+
+struct Entry {
+    point: &'static str,
+    key: Option<String>,
+    label: String,
+    disposable: Disposable,
+}
+
+/// Every declaration of a package, validated; nothing has taken effect yet.
+pub struct PreparedSet {
+    pub plugin: String,
+    /// Union of what the declarations need (beyond the manifest's own list).
+    pub capabilities: Vec<Capability>,
+    /// Package files the declarations reference.
+    pub files: Vec<PathBuf>,
+    /// Declarations for extension points this host does not know (skipped).
+    pub warnings: Vec<String>,
+    items: Vec<(&'static str, Prepared)>,
+}
+
+impl PreparedSet {
+    pub fn is_empty(&self) -> bool {
+        self.items.is_empty()
+    }
+
+    pub fn len(&self) -> usize {
+        self.items.len()
+    }
+}
+
+impl std::fmt::Debug for PreparedSet {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("PreparedSet")
+            .field("plugin", &self.plugin)
+            .field("items", &self.items.len())
+            .field("warnings", &self.warnings)
+            .finish()
+    }
+}
+
+#[derive(Default)]
+pub struct ExtensionRegistry {
+    points: RwLock<BTreeMap<&'static str, Arc<dyn ExtensionPoint>>>,
+    /// plugin id → its contributions in commit order.
+    entries: Mutex<BTreeMap<String, Vec<Entry>>>,
+}
+
+impl ExtensionRegistry {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Adds an extension point. Ids are unique.
+    pub fn register(&self, point: Arc<dyn ExtensionPoint>) -> Result<(), String> {
+        let id = point.id();
+        crate::manifest::validate_point_id(id)?;
+        let mut points = self.points.write();
+        if points.contains_key(id) {
+            return Err(format!("extension point {id:?} is already registered"));
+        }
+        points.insert(id, point);
+        Ok(())
+    }
+
+    pub fn point_ids(&self) -> Vec<&'static str> {
+        self.points.read().keys().copied().collect()
+    }
+
+    pub fn placement(&self, point: &str) -> Option<Placement> {
+        self.points.read().get(point).map(|p| p.placement())
+    }
+
+    fn point(&self, id: &str) -> Option<Arc<dyn ExtensionPoint>> {
+        self.points.read().get(id).cloned()
+    }
+
+    /// Validates every `contributes.<point>` declaration of `pkg`. Fails as a
+    /// whole on the first invalid declaration; unknown points are skipped with
+    /// a warning (forward compatibility).
+    pub fn prepare(&self, pkg: &Package) -> Result<PreparedSet, String> {
+        let mut set = PreparedSet {
+            plugin: pkg.id().to_owned(),
+            capabilities: Vec::new(),
+            files: Vec::new(),
+            warnings: Vec::new(),
+            items: Vec::new(),
+        };
+        for point_id in pkg.manifest.contributes.keys() {
+            let Some(point) = self.point(point_id) else {
+                let msg = format!("contributes.{point_id}: not supported by this version of the IDE; skipped");
+                tracing::warn!(plugin = %pkg.id(), "{msg}");
+                set.warnings.push(msg);
+                continue;
+            };
+            for (i, decl) in pkg.manifest.declarations(point_id).into_iter().enumerate() {
+                let prepared = point
+                    .prepare(pkg, decl)
+                    .map_err(|e| format!("contributes.{point_id}[{i}]: {}", strip_prefix(&e, point_id)))?;
+                for cap in &prepared.capabilities {
+                    if !set.capabilities.contains(cap) {
+                        set.capabilities.push(cap.clone());
+                    }
+                }
+                for f in &prepared.files {
+                    if !set.files.contains(f) {
+                        set.files.push(f.clone());
+                    }
+                }
+                set.items.push((point.id(), prepared));
+            }
+        }
+        Ok(set)
+    }
+
+    /// Makes a prepared set take effect, all or nothing: if one commit fails,
+    /// the ones before it are disposed in reverse order.
+    pub fn commit(&self, set: PreparedSet) -> Result<(), String> {
+        let mut committed: Vec<Entry> = Vec::with_capacity(set.items.len());
+        for (point, prepared) in set.items {
+            let Prepared { key, label, commit, .. } = prepared;
+            match commit() {
+                Ok(disposable) => committed.push(Entry { point, key, label, disposable }),
+                Err(e) => {
+                    tracing::error!(plugin = %set.plugin, "contributes.{point}: commit failed: {e}");
+                    while let Some(entry) = committed.pop() {
+                        entry.disposable.dispose();
+                    }
+                    return Err(format!("contributes.{point}: {e}"));
+                }
+            }
+        }
+        let replaced = {
+            let mut entries = self.entries.lock();
+            let list = entries.entry(set.plugin).or_default();
+            let mut replaced = Vec::new();
+            for new in &committed {
+                if let Some(key) = &new.key
+                    && let Some(pos) = list.iter().position(|e| e.point == new.point && e.key.as_ref() == Some(key))
+                {
+                    replaced.push(list.remove(pos));
+                }
+            }
+            list.extend(committed);
+            replaced
+        };
+        for old in replaced.into_iter().rev() {
+            old.disposable.dispose();
+        }
+        Ok(())
+    }
+
+    /// Withdraws everything `plugin` contributed, newest first.
+    pub fn dispose_plugin(&self, plugin: &str) -> bool {
+        let list = self.entries.lock().remove(plugin).unwrap_or_default();
+        let any = !list.is_empty();
+        for entry in list.into_iter().rev() {
+            entry.disposable.dispose();
+        }
+        any
+    }
+
+    pub fn contributions(&self, plugin: &str) -> Vec<ContributionInfo> {
+        self.entries
+            .lock()
+            .get(plugin)
+            .map(|list| {
+                list.iter().map(|e| ContributionInfo { point: e.point.into(), label: e.label.clone() }).collect()
+            })
+            .unwrap_or_default()
+    }
+
+    /// How many contributions `plugin` has at `point`.
+    pub fn count(&self, plugin: &str, point: &str) -> usize {
+        self.entries.lock().get(plugin).map_or(0, |list| list.iter().filter(|e| e.point == point).count())
+    }
+
+    /// Plugins with at least one contribution.
+    pub fn plugins(&self) -> Vec<String> {
+        self.entries.lock().iter().filter(|(_, l)| !l.is_empty()).map(|(id, _)| id.clone()).collect()
+    }
+}
+
+fn strip_prefix<'a>(e: &'a str, point: &str) -> &'a str {
+    e.strip_prefix(&format!("contributes.{point}: ")).unwrap_or(e)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::manifest::Manifest;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    /// Records live items in a shared list; `fail = true` makes commit fail.
+    struct Recording {
+        id: &'static str,
+        live: Arc<Mutex<Vec<String>>>,
+        commits: Arc<AtomicUsize>,
+    }
+
+    impl ExtensionPoint for Recording {
+        fn id(&self) -> &'static str {
+            self.id
+        }
+        fn placement(&self) -> Placement {
+            Placement::Ui
+        }
+        fn prepare(&self, _pkg: &Package, decl: toml::Value) -> Result<Prepared, String> {
+            let name = decl.get("name").and_then(|v| v.as_str()).ok_or("missing name")?.to_owned();
+            let fail = decl.get("fail").and_then(|v| v.as_bool()).unwrap_or(false);
+            let (live, commits) = (self.live.clone(), self.commits.clone());
+            let label = name.clone();
+            let mut p = Prepared::new(label, move || {
+                commits.fetch_add(1, Ordering::SeqCst);
+                if fail {
+                    return Err("boom".into());
+                }
+                live.lock().push(name.clone());
+                Ok(Disposable::new(move || live.lock().retain(|n| *n != name)))
+            });
+            if let Some(f) = decl.get("file").and_then(|v| v.as_str()) {
+                p = p.file(f);
+            }
+            if decl.get("key").and_then(|v| v.as_bool()).unwrap_or(false) {
+                p = p.key("k");
+            }
+            Ok(p)
+        }
+    }
+
+    fn setup() -> (ExtensionRegistry, Arc<Mutex<Vec<String>>>) {
+        let reg = ExtensionRegistry::new();
+        let live = Arc::new(Mutex::new(Vec::new()));
+        let commits = Arc::new(AtomicUsize::new(0));
+        reg.register(Arc::new(Recording { id: "things", live: live.clone(), commits: commits.clone() })).unwrap();
+        reg.register(Arc::new(Recording { id: "others", live: live.clone(), commits })).unwrap();
+        (reg, live)
+    }
+
+    fn pkg(contributes: &str) -> Package {
+        let src = format!("id = \"p\"\nname = \"P\"\nversion = \"1.0.0\"\nengines.openidea = \"^1.0\"\n{contributes}");
+        Package::new(Manifest::parse(&src).unwrap(), PathBuf::from("/nonexistent"))
+    }
+
+    #[test]
+    fn commits_and_disposes_per_plugin() {
+        let (reg, live) = setup();
+        assert!(
+            reg.register(Arc::new(Recording { id: "things", live: live.clone(), commits: Default::default() }))
+                .is_err()
+        );
+        let p = pkg(
+            "[[contributes.things]]\nname = \"a\"\nfile = \"x.json\"\n[[contributes.things]]\nname = \"b\"\n[contributes.others]\nname = \"c\"",
+        );
+        let set = reg.prepare(&p).unwrap();
+        assert_eq!(set.len(), 3);
+        assert_eq!(set.files, [PathBuf::from("x.json")]);
+        assert!(live.lock().is_empty(), "prepare has no side effects");
+        reg.commit(set).unwrap();
+        assert_eq!(*live.lock(), ["c", "a", "b"]);
+        assert_eq!(reg.count("p", "things"), 2);
+        assert_eq!(reg.contributions("p").len(), 3);
+        assert!(reg.dispose_plugin("p"));
+        assert!(live.lock().is_empty());
+    }
+
+    #[test]
+    fn a_failed_commit_rolls_back() {
+        let (reg, live) = setup();
+        let p = pkg("[[contributes.things]]\nname = \"a\"\n[[contributes.things]]\nname = \"b\"\nfail = true");
+        let err = reg.commit(reg.prepare(&p).unwrap()).unwrap_err();
+        assert!(err.contains("boom"));
+        assert!(live.lock().is_empty(), "a was undone");
+        assert!(reg.contributions("p").is_empty());
+    }
+
+    #[test]
+    fn invalid_declarations_fail_prepare_and_unknown_points_warn() {
+        let (reg, _) = setup();
+        let err = reg.prepare(&pkg("[[contributes.things]]\nnope = 1")).unwrap_err();
+        assert_eq!(err, "contributes.things[0]: missing name");
+        let set =
+            reg.prepare(&pkg("[[contributes.futureThing]]\nx = 1\n[[contributes.things]]\nname = \"a\"")).unwrap();
+        assert_eq!(set.len(), 1);
+        assert_eq!(set.warnings.len(), 1);
+        assert!(set.warnings[0].contains("futureThing"));
+    }
+}

crates/ide-extension/src/ui.rs

@@ -0,0 +1,247 @@
+//! UI contributions: validated declarations projected to the client.
+//!
+//! A `Ui` extension point validates a declaration completely in Rust and
+//! commits it as JSON into the [`UiStore`]; the client receives the store's
+//! snapshot and projects each item onto an existing `register*` function
+//! (`defineUiPoint` in `src/features/plugins/projection.ts`). Large payloads
+//! (icon SVGs) go into the store's assets and are fetched on demand.
+
+use crate::index::ContributionIndex;
+use crate::point::{Disposable, ExtensionPoint, Package, Placement, Prepared};
+use parking_lot::RwLock;
+use serde::{Deserialize, Serialize};
+use specta::Type;
+use std::collections::BTreeMap;
+use std::path::PathBuf;
+use std::sync::Arc;
+use std::sync::atomic::{AtomicU64, Ordering};
+
+/// One projected declaration.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct UiContribution {
+    pub plugin_id: String,
+    /// Extension point id (`commands`, `iconThemes`, …).
+    pub point: String,
+    /// Stable within (plugin, point): the client keys its registrations on it.
+    pub key: String,
+    /// The validated declaration, shaped by the point.
+    #[specta(type = specta_typescript::Unknown)]
+    pub decl: serde_json::Value,
+}
+
+struct Item {
+    seq: u64,
+    contribution: UiContribution,
+}
+
+/// Committed UI contributions of all plugins.
+#[derive(Default)]
+pub struct UiStore {
+    items: RwLock<Vec<Item>>,
+    /// (plugin, asset id) → content.
+    assets: RwLock<BTreeMap<(String, String), Arc<str>>>,
+    seq: AtomicU64,
+    revision: AtomicU64,
+    index: RwLock<Option<Arc<ContributionIndex>>>,
+}
+
+impl UiStore {
+    pub fn new() -> Arc<Self> {
+        Arc::new(Self::default())
+    }
+
+    /// Adds an item; the returned disposable removes it.
+    pub fn insert(self: &Arc<Self>, contribution: UiContribution) -> Disposable {
+        let seq = self.seq.fetch_add(1, Ordering::Relaxed);
+        self.items.write().push(Item { seq, contribution });
+        self.revision.fetch_add(1, Ordering::Release);
+        let store = Arc::downgrade(self);
+        Disposable::new(move || {
+            if let Some(store) = store.upgrade() {
+                store.items.write().retain(|i| i.seq != seq);
+                store.revision.fetch_add(1, Ordering::Release);
+            }
+        })
+    }
+
+    /// Stores assets of a plugin (ids are unique per plugin; later ones replace).
+    pub fn insert_assets(self: &Arc<Self>, plugin: &str, assets: Vec<(String, String)>) -> Disposable {
+        let keys: Vec<(String, String)> = assets.iter().map(|(id, _)| (plugin.to_owned(), id.clone())).collect();
+        {
+            let mut map = self.assets.write();
+            for (id, content) in assets {
+                map.insert((plugin.to_owned(), id), Arc::from(content));
+            }
+        }
+        let store = Arc::downgrade(self);
+        Disposable::new(move || {
+            if let Some(store) = store.upgrade() {
+                let mut map = store.assets.write();
+                for k in keys {
+                    map.remove(&k);
+                }
+            }
+        })
+    }
+
+    pub fn asset(&self, plugin: &str, id: &str) -> Option<Arc<str>> {
+        self.assets.read().get(&(plugin.to_owned(), id.to_owned())).cloned()
+    }
+
+    /// Assets of `plugin` whose id starts with `prefix`.
+    pub fn assets_with_prefix(&self, plugin: &str, prefix: &str) -> Vec<(String, Arc<str>)> {
+        self.assets
+            .read()
+            .range((plugin.to_owned(), prefix.to_owned())..)
+            .take_while(|((p, id), _)| p == plugin && id.starts_with(prefix))
+            .map(|((_, id), v)| (id.clone(), v.clone()))
+            .collect()
+    }
+
+    /// Where [`UiPoint`]s keep validated declarations of installed packages.
+    pub fn set_index(&self, index: Option<Arc<ContributionIndex>>) {
+        *self.index.write() = index;
+    }
+
+    /// Bumped on every change: clients compare it to skip re-projection.
+    pub fn revision(&self) -> u64 {
+        self.revision.load(Ordering::Acquire)
+    }
+
+    pub fn snapshot(&self) -> Vec<UiContribution> {
+        self.items.read().iter().map(|i| i.contribution.clone()).collect()
+    }
+
+    /// Items of one point, optionally of one plugin.
+    pub fn items(&self, point: &str, plugin: Option<&str>) -> Vec<UiContribution> {
+        self.items
+            .read()
+            .iter()
+            .filter(|i| i.contribution.point == point && plugin.is_none_or(|p| i.contribution.plugin_id == p))
+            .map(|i| i.contribution.clone())
+            .collect()
+    }
+}
+
+/// What a [`UiPoint`]'s validator produces for one declaration.
+#[derive(Debug, Serialize, Deserialize)]
+pub struct UiDecl {
+    pub key: String,
+    pub label: String,
+    pub json: serde_json::Value,
+    /// Package files referenced (copied on install).
+    pub files: Vec<PathBuf>,
+    /// Large validated payloads fetched separately by the client.
+    pub assets: Vec<(String, String)>,
+}
+
+impl UiDecl {
+    pub fn new(key: impl Into<String>, label: impl Into<String>, json: serde_json::Value) -> Self {
+        Self { key: key.into(), label: label.into(), json, files: Vec::new(), assets: Vec::new() }
+    }
+}
+
+type Validate = dyn Fn(&Package, toml::Value) -> Result<UiDecl, String> + Send + Sync;
+
+/// A `Ui` extension point defined by a validator: committing stores the
+/// validated JSON (and assets) in the [`UiStore`]. Most UI contribution types
+/// (menus, keybindings, status bar items, icon themes) are one of these.
+pub struct UiPoint {
+    id: &'static str,
+    store: Arc<UiStore>,
+    validate: Box<Validate>,
+}
+
+impl UiPoint {
+    pub fn new(
+        id: &'static str,
+        store: Arc<UiStore>,
+        validate: impl Fn(&Package, toml::Value) -> Result<UiDecl, String> + Send + Sync + 'static,
+    ) -> Self {
+        Self { id, store, validate: Box::new(validate) }
+    }
+}
+
+impl ExtensionPoint for UiPoint {
+    fn id(&self) -> &'static str {
+        self.id
+    }
+
+    fn placement(&self) -> Placement {
+        Placement::Ui
+    }
+
+    fn prepare(&self, pkg: &Package, decl: toml::Value) -> Result<Prepared, String> {
+        let index = pkg.digest.as_ref().and_then(|_| self.store.index.read().clone());
+        let ui = match index.as_ref().and_then(|i| i.get(pkg, self.id, &decl)) {
+            Some(ui) => ui,
+            None => match &index {
+                Some(i) => {
+                    let ui = (self.validate)(pkg, decl.clone())?;
+                    i.put(pkg, self.id, &decl, &ui);
+                    ui
+                }
+                None => (self.validate)(pkg, decl)?,
+            },
+        };
+        let UiDecl { key, label, json, files, assets } = ui;
+        let store = self.store.clone();
+        let contribution =
+            UiContribution { plugin_id: pkg.id().to_owned(), point: self.id.to_owned(), key: key.clone(), decl: json };
+        let plugin = pkg.id().to_owned();
+        let mut prepared = Prepared::new(label, move || {
+            let item = store.insert(contribution);
+            if assets.is_empty() {
+                return Ok(item);
+            }
+            let assets = store.insert_assets(&plugin, assets);
+            Ok(Disposable::new(move || {
+                item.dispose();
+                assets.dispose();
+            }))
+        })
+        .key(key);
+        prepared.files = files;
+        Ok(prepared)
+    }
+}
+
+/// TOML declaration → JSON for the client.
+pub fn to_json(v: &toml::Value) -> serde_json::Value {
+    serde_json::to_value(v).unwrap_or(serde_json::Value::Null)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::manifest::Manifest;
+    use crate::registry::ExtensionRegistry;
+
+    #[test]
+    fn ui_point_projects_into_the_store() {
+        let store = UiStore::new();
+        let reg = ExtensionRegistry::new();
+        reg.register(Arc::new(UiPoint::new("badges", store.clone(), |_pkg, decl| {
+            let text = decl.get("text").and_then(|v| v.as_str()).ok_or("missing text")?.to_owned();
+            let mut d = UiDecl::new(text.clone(), text.clone(), serde_json::json!({ "text": text }));
+            d.assets.push((format!("badge/{text}"), "<svg/>".into()));
+            Ok(d)
+        })))
+        .unwrap();
+        let src = "id = \"p\"\nname = \"P\"\nversion = \"1.0.0\"\nengines.openidea = \"^1.0\"\n\
+                   [[contributes.badges]]\ntext = \"hi\"";
+        let pkg = Package::new(Manifest::parse(src).unwrap(), PathBuf::from("/x"));
+        let rev = store.revision();
+        reg.commit(reg.prepare(&pkg).unwrap()).unwrap();
+        assert!(store.revision() > rev);
+        let items = store.items("badges", Some("p"));
+        assert_eq!(items.len(), 1);
+        assert_eq!(items[0].decl["text"], "hi");
+        assert_eq!(store.asset("p", "badge/hi").as_deref(), Some("<svg/>"));
+        assert_eq!(store.assets_with_prefix("p", "badge/").len(), 1);
+        reg.dispose_plugin("p");
+        assert!(store.snapshot().is_empty());
+        assert!(store.asset("p", "badge/hi").is_none());
+    }
+}

crates/ide-extension/src/when.rs

@@ -0,0 +1,136 @@
+//! Syntax check for `when` clauses in UI declarations. The client evaluates
+//! them (`src/platform/context.ts`); validating here keeps the client's
+//! projection from failing. Grammar (same as the client):
+//!
+//! ```text
+//! expr := or ; or := and ("||" and)* ; and := unary ("&&" unary)*
+//! unary := "!" unary | "(" expr ")" | cmp ; cmp := key (("==" | "!=") value)?
+//! ```
+
+const MAX_LEN: usize = 512;
+
+#[derive(Debug, PartialEq)]
+enum Tok<'a> {
+    Id(&'a str),
+    Str,
+    Op(&'a str),
+}
+
+fn tokenize(src: &str) -> Result<Vec<Tok<'_>>, String> {
+    let mut out = Vec::new();
+    let b = src.as_bytes();
+    let mut i = 0;
+    while i < b.len() {
+        let c = b[i] as char;
+        if c.is_whitespace() {
+            i += 1;
+        } else if ["&&", "||", "==", "!="].iter().any(|op| src[i..].starts_with(op)) {
+            out.push(Tok::Op(&src[i..i + 2]));
+            i += 2;
+        } else if matches!(c, '!' | '(' | ')') {
+            out.push(Tok::Op(&src[i..i + 1]));
+            i += 1;
+        } else if c == '\'' || c == '"' {
+            let end = src[i + 1..].find(c).ok_or_else(|| format!("unterminated string in when clause: {src}"))?;
+            out.push(Tok::Str);
+            i += end + 2;
+        } else {
+            let len = src[i..]
+                .find(|ch: char| !(ch.is_alphanumeric() || matches!(ch, '_' | '.' | '-' | ':' | '/')))
+                .unwrap_or(src.len() - i);
+            if len == 0 {
+                return Err(format!("unexpected '{c}' in when clause: {src}"));
+            }
+            out.push(Tok::Id(&src[i..i + len]));
+            i += len;
+        }
+    }
+    Ok(out)
+}
+
+/// Checks a `when` clause; empty means "always".
+pub fn validate_when(src: &str) -> Result<(), String> {
+    if src.len() > MAX_LEN {
+        return Err(format!("when clause longer than {MAX_LEN} bytes"));
+    }
+    if src.trim().is_empty() {
+        return Ok(());
+    }
+    let toks = tokenize(src)?;
+    let mut p = 0;
+    parse_or(&toks, &mut p, src)?;
+    if p != toks.len() {
+        return Err(format!("unexpected token in when clause: {src}"));
+    }
+    Ok(())
+}
+
+fn parse_or(t: &[Tok], p: &mut usize, src: &str) -> Result<(), String> {
+    parse_and(t, p, src)?;
+    while t.get(*p) == Some(&Tok::Op("||")) {
+        *p += 1;
+        parse_and(t, p, src)?;
+    }
+    Ok(())
+}
+
+fn parse_and(t: &[Tok], p: &mut usize, src: &str) -> Result<(), String> {
+    parse_unary(t, p, src)?;
+    while t.get(*p) == Some(&Tok::Op("&&")) {
+        *p += 1;
+        parse_unary(t, p, src)?;
+    }
+    Ok(())
+}
+
+fn parse_unary(t: &[Tok], p: &mut usize, src: &str) -> Result<(), String> {
+    match t.get(*p) {
+        Some(Tok::Op("!")) => {
+            *p += 1;
+            parse_unary(t, p, src)
+        }
+        Some(Tok::Op("(")) => {
+            *p += 1;
+            parse_or(t, p, src)?;
+            if t.get(*p) != Some(&Tok::Op(")")) {
+                return Err(format!("missing ')' in when clause: {src}"));
+            }
+            *p += 1;
+            Ok(())
+        }
+        Some(Tok::Id(_)) => {
+            *p += 1;
+            if matches!(t.get(*p), Some(Tok::Op("==" | "!="))) {
+                *p += 1;
+                match t.get(*p) {
+                    Some(Tok::Id(_) | Tok::Str) => *p += 1,
+                    _ => return Err(format!("missing value after comparison in when clause: {src}")),
+                }
+            }
+            Ok(())
+        }
+        _ => Err(format!("expected a context key in when clause: {src}")),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::validate_when;
+
+    #[test]
+    fn accepts_the_client_grammar() {
+        for ok in [
+            "",
+            "editorFocus",
+            "editorLang == rust",
+            "editorLang != 'rust' && !readOnly",
+            "(a || b) && toolWindow.project.active",
+            "resourceScheme == file:/x",
+        ] {
+            assert!(validate_when(ok).is_ok(), "{ok}");
+        }
+        for bad in ["a &&", "(a", "a == ", "== a", "a b", "a $ b", "'x", "!()"] {
+            assert!(validate_when(bad).is_err(), "{bad}");
+        }
+    }
+}

crates/ide-fonts/src/lib.rs

@@ -21,6 +21,18 @@ pub struct FontFamily {
     pub monospaced: bool,
 }
 
+/// PANOSE bProportion value 9 means "Monospaced"; DirectWrite's
+/// `IsMonospacedFont` alone misses fonts that only carry this classification.
+const PANOSE_MONOSPACED: u8 = 9;
+
+/// One face counts as monospaced when the font system flags it fixed pitch, its
+/// PANOSE proportion is "Monospaced", or its glyph advances are uniform
+/// (fonts with wrong/missing metadata, e.g. bitmap-style TTFs).
+#[cfg_attr(not(windows), allow(dead_code))]
+fn face_is_mono(is_monospaced_font: bool, panose_proportion: u8, advances_equal: bool) -> bool {
+    is_monospaced_font || panose_proportion == PANOSE_MONOSPACED || advances_equal
+}
+
 type Cache = Mutex<Option<Arc<[FontFamily]>>>;
 
 /// The installed families, sorted case-insensitively, read on first use and
@@ -195,7 +207,9 @@ mod imp {
         // SAFETY: CoreText descriptors carry documented CFString, CFURL and trait dictionary values.
         unsafe {
             let collection = CTFontCollection::from_available_fonts(None);
-            let Some(descriptors) = collection.matching_font_descriptors() else { return Vec::new() };
+            let Some(descriptors) = collection.matching_font_descriptors() else {
+                return Vec::new();
+            };
             let mut seen = std::collections::BTreeSet::new();
             descriptors
                 .cast_unchecked::<CTFontDescriptor>()
@@ -271,14 +285,16 @@ mod imp {
 
 #[cfg(windows)]
 mod imp {
+    use std::os::windows::ffi::OsStrExt;
+    use windows::Win32::Graphics::DirectWrite::IDWriteFontFace1;
     use windows::Win32::Graphics::DirectWrite::{
-        DWRITE_FACTORY_TYPE_SHARED, DWRITE_FONT_STRETCH_NORMAL, DWRITE_FONT_STYLE_NORMAL, DWRITE_FONT_WEIGHT_NORMAL,
-        DWriteCreateFactory, IDWriteFactory, IDWriteFont1, IDWriteLocalizedStrings,
+        DWRITE_FACTORY_TYPE_SHARED, DWriteCreateFactory, IDWriteFactory, IDWriteFactory3, IDWriteFactory5, IDWriteFont,
+        IDWriteFont1, IDWriteFontCollection, IDWriteFontFamily, IDWriteLocalizedStrings,
     };
-    use windows::core::{BOOL, Interface, w};
+    use windows::core::{BOOL, Interface, PCWSTR, w};
 
-    /// The system font collection's families, named in English when the
-    /// family has an English name (what CSS matches), else its first name.
+    /// The installed families, named in English when the family has an
+    /// English name (what CSS matches), else its first name.
     pub(crate) fn list(refresh: bool) -> Vec<(String, bool)> {
         // SAFETY: plain DirectWrite COM calls on interfaces we own.
         unsafe { read(refresh) }.unwrap_or_default()
@@ -286,11 +302,85 @@ mod imp {
 
     unsafe fn read(refresh: bool) -> windows::core::Result<Vec<(String, bool)>> {
         let factory: IDWriteFactory = unsafe { DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED) }?;
+        let mut faces = Vec::new();
+        // Windows 10+: the newer collection covers registered per-user fonts.
+        // Exclude downloadable fonts that are not installed on this machine.
+        // Bitmap .FON fonts (e.g. the stock raster Fixedsys) are invisible to
+        // DirectWrite either way: it only reads TrueType/OpenType files.
         let mut collection = None;
-        unsafe { factory.GetSystemFontCollection(&mut collection, refresh) }?;
-        let Some(collection) = collection else {
-            return Ok(Vec::new());
+        if let Ok(factory3) = factory.cast::<IDWriteFactory3>() {
+            let mut local = None;
+            if unsafe { factory3.GetSystemFontCollection(false, &mut local, refresh) }.is_ok() {
+                collection = local.map(Into::into);
+            }
+        }
+        if collection.is_none() {
+            unsafe { factory.GetSystemFontCollection(&mut collection, refresh) }?;
+        }
+        if let Some(collection) = collection {
+            faces.extend(collect(&collection));
+        }
+        // DirectWrite enumerates via the font registry, so font files copied
+        // into the per-user directory without registering (no HKCU entry)
+        // are invisible to the calls above; scan the directory directly.
+        faces.extend(unsafe { user_dir_faces(&factory) });
+        Ok(faces)
+    }
+
+    /// Families from `%LOCALAPPDATA%\Microsoft\Windows\Fonts` files, registered
+    /// or not, via a font set built from the files on disk.
+    unsafe fn user_dir_faces(factory: &IDWriteFactory) -> Vec<(String, bool)> {
+        let Some(local_app_data) = std::env::var_os("LOCALAPPDATA") else {
+            return Vec::new();
         };
+        let dir = std::path::Path::new(&local_app_data).join(r"Microsoft\Windows\Fonts");
+        let Ok(entries) = std::fs::read_dir(&dir) else {
+            return Vec::new();
+        };
+        let files: Vec<_> = entries
+            .filter_map(|e| e.ok())
+            .map(|e| e.path())
+            .filter(|p| {
+                matches!(
+                    p.extension().and_then(|e| e.to_str()).map(|e| e.to_ascii_lowercase()).as_deref(),
+                    Some("ttf" | "otf" | "ttc" | "otc")
+                )
+            })
+            .collect();
+        unsafe { file_faces(factory, &files) }
+    }
+
+    unsafe fn file_faces(factory: &IDWriteFactory, files: &[std::path::PathBuf]) -> Vec<(String, bool)> {
+        if files.is_empty() {
+            return Vec::new();
+        }
+        let Ok(factory3) = factory.cast::<IDWriteFactory3>() else {
+            return Vec::new();
+        };
+        let Ok(factory5) = factory.cast::<IDWriteFactory5>() else {
+            return Vec::new();
+        };
+        let Ok(builder) = (unsafe { factory5.CreateFontSetBuilder() }) else {
+            return Vec::new();
+        };
+        for path in files {
+            let wide: Vec<u16> = path.as_os_str().encode_wide().chain(Some(0)).collect();
+            // SAFETY: wide is a valid NUL-terminated string for the calls.
+            let Ok(file) = (unsafe { factory.CreateFontFileReference(PCWSTR(wide.as_ptr()), None) }) else {
+                continue;
+            };
+            let _ = unsafe { builder.AddFontFile(&file) };
+        }
+        let Ok(set) = (unsafe { builder.CreateFontSet() }) else {
+            return Vec::new();
+        };
+        let Ok(collection) = (unsafe { factory3.CreateFontCollectionFromFontSet(&set) }) else {
+            return Vec::new();
+        };
+        collect(&collection)
+    }
+
+    fn collect(collection: &IDWriteFontCollection) -> Vec<(String, bool)> {
         let mut out = Vec::new();
         for i in 0..unsafe { collection.GetFontFamilyCount() } {
             let Ok(family) = (unsafe { collection.GetFontFamily(i) }) else {
@@ -299,19 +389,120 @@ mod imp {
             let Some(name) = unsafe { family.GetFamilyNames() }.ok().and_then(|n| unsafe { english(&n) }) else {
                 continue;
             };
-            let mono = unsafe {
-                family.GetFirstMatchingFont(
-                    DWRITE_FONT_WEIGHT_NORMAL,
-                    DWRITE_FONT_STRETCH_NORMAL,
-                    DWRITE_FONT_STYLE_NORMAL,
-                )
-            }
-            .ok()
-            .and_then(|f| f.cast::<IDWriteFont1>().ok())
-            .is_some_and(|f| unsafe { f.IsMonospacedFont() }.as_bool());
-            out.push((name, mono));
+            out.push((name, unsafe { family_is_mono(&family) }));
+        }
+        out
+    }
+
+    /// A family is monospaced when any face reports fixed pitch, PANOSE
+    /// proportion 9, or uniform glyph advances; probing every face matches
+    /// `normalize`'s any-face merge (macOS and Linux already flag every face,
+    /// not just the regular one).
+    unsafe fn family_is_mono(family: &IDWriteFontFamily) -> bool {
+        (0..unsafe { family.GetFontCount() }).any(|i| {
+            let Ok(font) = (unsafe { family.GetFont(i) }) else {
+                return false;
+            };
+            if let Ok(font1) = font.cast::<IDWriteFont1>() {
+                let is_monospaced = unsafe { font1.IsMonospacedFont() }.as_bool();
+                // The proportion byte is defined for text/display fonts only.
+                let panose = unsafe { font1.GetPanose().values };
+                let panose_proportion = if panose[0] == 2 { panose[3] } else { 0 };
+                if super::face_is_mono(is_monospaced, panose_proportion, false) {
+                    return true;
+                }
+            }
+            unsafe { advances_equal(&font) }
+        })
+    }
+
+    /// Some monospaced fonts carry no fixed-pitch metadata at all (bitmap-style
+    /// TTFs like Fixedsys Excelsior): compare the advance widths of 'i' and
+    /// 'W'. Dual-width CJK monospace fonts pass too (both half-width).
+    unsafe fn advances_equal(font: &IDWriteFont) -> bool {
+        let Ok(face) = (unsafe { font.CreateFontFace() }) else {
+            return false;
+        };
+        let Ok(face1) = face.cast::<IDWriteFontFace1>() else {
+            return false;
+        };
+        let codepoints = ['i' as u32, 'W' as u32];
+        let mut indices = [0u16; 2];
+        if unsafe { face.GetGlyphIndices(codepoints.as_ptr(), 2, indices.as_mut_ptr()) }.is_err()
+            || indices.contains(&0)
+        {
+            return false;
+        }
+        let mut advances = [0i32; 2];
+        unsafe { face1.GetDesignGlyphAdvances(2, indices.as_ptr(), advances.as_mut_ptr(), false) }.is_ok()
+            && advances[0] > 0
+            && advances[0] == advances[1]
+    }
+
+    #[test]
+    fn glyph_probe_distinguishes_monospace_proportional_and_symbol_fonts() {
+        unsafe {
+            let factory: IDWriteFactory = DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED).unwrap();
+            let mut collection = None;
+            factory.GetSystemFontCollection(&mut collection, false).unwrap();
+            let collection = collection.unwrap();
+            for (name, expected) in [
+                ("Consolas", true),
+                ("Arial", false),
+                ("Times New Roman", false),
+                ("Wingdings", false),
+                ("Webdings", false),
+                ("Segoe MDL2 Assets", false),
+            ] {
+                let wide: Vec<_> = name.encode_utf16().chain(Some(0)).collect();
+                let mut index = 0;
+                let mut exists = BOOL(0);
+                collection.FindFamilyName(PCWSTR(wide.as_ptr()), &mut index, &mut exists).unwrap();
+                assert!(exists.as_bool(), "{name} ships with Windows");
+                let family = collection.GetFontFamily(index).unwrap();
+                for i in 0..family.GetFontCount() {
+                    let font = family.GetFont(i).unwrap();
+                    assert_eq!(advances_equal(&font), expected, "{name} face {i}");
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn font_files_include_every_family_in_a_collection() {
+        let path = std::path::PathBuf::from(std::env::var_os("WINDIR").unwrap()).join(r"Fonts\cambria.ttc");
+        unsafe {
+            let factory: IDWriteFactory = DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED).unwrap();
+            let faces = file_faces(&factory, &[path]);
+            for name in ["Cambria", "Cambria Math"] {
+                assert!(faces.iter().any(|(family, _)| family == name), "missing {name}: {faces:?}");
+            }
+        }
+    }
+
+    #[test]
+    fn excludes_families_available_only_as_downloads() {
+        use windows::Win32::Graphics::DirectWrite::{DWRITE_E_REMOTEFONT, DWRITE_LOCALITY_LOCAL, IDWriteFont3};
+
+        unsafe {
+            let factory: IDWriteFactory = DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED).unwrap();
+            let factory3: IDWriteFactory3 = factory.cast().unwrap();
+            let set = factory3.GetSystemFontSet().unwrap();
+            let collection = factory3.CreateFontCollectionFromFontSet(&set).unwrap();
+            let listed = super::normalize(read(false).unwrap());
+            let user = super::normalize(user_dir_faces(&factory));
+            for i in 0..collection.GetFontFamilyCount() {
+                let family = collection.GetFontFamily(i).unwrap();
+                let name = english(&family.GetFamilyNames().unwrap()).unwrap();
+                let remote_only = (0..family.GetFontCount()).all(|j| match family.GetFont(j) {
+                    Ok(font) => font.cast::<IDWriteFont3>().unwrap().GetLocality() != DWRITE_LOCALITY_LOCAL,
+                    Err(error) => error.code() == DWRITE_E_REMOTEFONT,
+                });
+                if remote_only && !user.iter().any(|f| f.name == name) {
+                    assert!(!listed.iter().any(|f| f.name == name), "{name} is not installed locally");
+                }
+            }
         }
-        Ok(out)
     }
 
     unsafe fn english(names: &IDWriteLocalizedStrings) -> Option<String> {
@@ -476,6 +667,15 @@ mod tests {
         );
     }
 
+    #[test]
+    fn panose_monospaced_proportion_counts_as_mono() {
+        assert!(face_is_mono(true, 0, false));
+        assert!(face_is_mono(false, PANOSE_MONOSPACED, false));
+        assert!(face_is_mono(false, 0, true));
+        assert!(!face_is_mono(false, 0, false));
+        assert!(!face_is_mono(false, 3, false));
+    }
+
     #[test]
     fn fc_list_spacing_marks_monospace() {
         let out = "DejaVu Sans Mono\t100\nDejaVu Sans\t\nNoto Sans Mono CJK SC\t90\nTerminus\t110\nCantarell\nFira\\-Code\tmono\n\t100\n";

crates/ide-github/src/account.rs

@@ -0,0 +1,145 @@
+//! The signed-in GitHub account, independent of any project: its repositories for
+//! "Get from Version Control" › GitHub.
+
+use crate::{GhAvailability, QUICK, classify_failure, command, gh_executable, process};
+use serde::{Deserialize, Serialize};
+use specta::Type;
+
+/// A repository of the signed-in account (owned, collaborator, or organization member).
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct GhAccountRepo {
+    /// `owner/name`.
+    pub name_with_owner: String,
+    pub description: Option<String>,
+    pub private: bool,
+    pub fork: bool,
+    pub archived: bool,
+    /// What `git clone` takes: HTTPS, or SSH when gh's `git_protocol` is `ssh`.
+    pub clone_url: String,
+}
+
+/// The account's repositories, or why they can't be listed.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase", tag = "kind")]
+pub enum GhAccountRepos {
+    Ready {
+        login: String,
+        repos: Vec<GhAccountRepo>,
+    },
+    /// No `gh` executable was found.
+    NotInstalled,
+    /// `gh auth login` has not been run (or the token expired).
+    NotLoggedIn {
+        message: String,
+    },
+    Error {
+        message: String,
+    },
+}
+
+#[derive(Deserialize)]
+struct RestRepo {
+    full_name: String,
+    description: Option<String>,
+    #[serde(default)]
+    private: bool,
+    #[serde(default)]
+    fork: bool,
+    #[serde(default)]
+    archived: bool,
+    clone_url: String,
+    ssh_url: String,
+}
+
+/// `gh api --paginate --slurp user/repos` output: one array per page.
+pub fn parse_account_repos(slurped: &str, ssh: bool) -> Result<Vec<GhAccountRepo>, serde_json::Error> {
+    let pages: Vec<Vec<RestRepo>> = serde_json::from_str(slurped)?;
+    Ok(pages
+        .into_iter()
+        .flatten()
+        .map(|r| GhAccountRepo {
+            name_with_owner: r.full_name,
+            description: r.description.filter(|d| !d.trim().is_empty()),
+            private: r.private,
+            fork: r.fork,
+            archived: r.archived,
+            clone_url: if ssh { r.ssh_url } else { r.clone_url },
+        })
+        .collect())
+}
+
+/// Lists the repositories of the account gh is signed in to, most recently pushed first.
+pub fn account_repositories() -> GhAccountRepos {
+    if gh_executable().is_none() {
+        return GhAccountRepos::NotInstalled;
+    }
+    let dir = std::env::temp_dir();
+    let gh = |args: &[&str]| -> Result<String, GhAccountRepos> {
+        let out = command(&dir, args)
+            .and_then(|cmd| process::run(cmd, QUICK, None))
+            .map_err(|e| GhAccountRepos::Error { message: e.message })?;
+        if out.success {
+            return Ok(out.stdout);
+        }
+        let message = if out.stderr.trim().is_empty() { out.stdout } else { out.stderr };
+        Err(match classify_failure(&message) {
+            GhAvailability::NotLoggedIn { message } => GhAccountRepos::NotLoggedIn { message },
+            _ => GhAccountRepos::Error { message: message.trim().to_owned() },
+        })
+    };
+    let result = (|| {
+        let login = gh(&["api", "user", "--jq", ".login"])?.trim().to_owned();
+        let ssh = gh(&["config", "get", "git_protocol", "--host", "github.com"]).is_ok_and(|p| p.trim() == "ssh");
+        let pages = gh(&[
+            "api",
+            "user/repos?per_page=100&sort=pushed&affiliation=owner,collaborator,organization_member",
+            "--paginate",
+            "--slurp",
+        ])?;
+        let repos = parse_account_repos(&pages, ssh)
+            .map_err(|e| GhAccountRepos::Error { message: format!("unexpected gh output: {e}") })?;
+        Ok(GhAccountRepos::Ready { login, repos })
+    })();
+    result.unwrap_or_else(|e| e)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn reads_every_page_and_picks_the_configured_protocol() {
+        let pages = r#"[
+          [{"full_name":"me/app","description":"An app","private":true,"fork":false,"archived":false,
+            "clone_url":"https://github.com/me/app.git","ssh_url":"[email protected]:me/app.git"}],
+          [{"full_name":"org/lib","description":"","fork":true,
+            "clone_url":"https://github.com/org/lib.git","ssh_url":"[email protected]:org/lib.git"}]
+        ]"#;
+        let https = parse_account_repos(pages, false).unwrap();
+        assert_eq!(
+            https,
+            vec![
+                GhAccountRepo {
+                    name_with_owner: "me/app".into(),
+                    description: Some("An app".into()),
+                    private: true,
+                    fork: false,
+                    archived: false,
+                    clone_url: "https://github.com/me/app.git".into(),
+                },
+                GhAccountRepo {
+                    name_with_owner: "org/lib".into(),
+                    description: None,
+                    private: false,
+                    fork: true,
+                    archived: false,
+                    clone_url: "https://github.com/org/lib.git".into(),
+                },
+            ]
+        );
+        let ssh = parse_account_repos(pages, true).unwrap();
+        assert_eq!(ssh[1].clone_url, "[email protected]:org/lib.git");
+        assert!(parse_account_repos("[]", false).unwrap().is_empty());
+    }
+}

crates/ide-github/src/lib.rs

@@ -3,9 +3,11 @@
 //!
 //! Every function blocks; callers run them off the UI / command threads.
 
+mod account;
 mod model;
 mod process;
 
+pub use account::{GhAccountRepo, GhAccountRepos, account_repositories, parse_account_repos};
 pub use model::*;
 
 use ide_core::{CancellationToken, IdeError, IdeResult};

crates/ide-host/Cargo.toml

@@ -14,6 +14,7 @@ encoding_rs.workspace = true
 ide-core.workspace = true
 ide-text.workspace = true
 ide-vfs.workspace = true
+regex-syntax.workspace = true
 ide-workspace.workspace = true
 ide-language.workspace = true
 ide-index.workspace = true
@@ -30,15 +31,25 @@ ide-terminal.workspace = true
 ide-run.workspace = true
 ide-sdk.workspace = true
 ide-http.workspace = true
+reqwest.workspace = true
+ignore.workspace = true
+base64.workspace = true
+getrandom = "0.3"
+globset.workspace = true
 ide-db.workspace = true
 ide-ssh.workspace = true
 ide-remote.workspace = true
 ide-jsonrpc.workspace = true
 ide-agent.workspace = true
 ide-notebook.workspace = true
+ide-extension.workspace = true
+ide-plugin.workspace = true
 ide-tools = { path = "../ide-tools" }
+ide-docker = { path = "../ide-docker" }
+semver = "1"
 serde.workspace = true
 serde_json.workspace = true
+toml.workspace = true
 specta.workspace = true
 specta-typescript.workspace = true
 tokio = { workspace = true, features = ["io-std"] }
@@ -49,13 +60,20 @@ dunce.workspace = true
 dirs.workspace = true
 uuid.workspace = true
 tempfile.workspace = true
+zip.workspace = true
+quick-xml = "0.42"
 
 [dev-dependencies]
 ide-ssh = { workspace = true, features = ["testing"] }
 tokio = { workspace = true, features = ["rt-multi-thread", "macros", "io-util", "test-util"] }
+criterion = { version = "0.5", default-features = false }
 
 [target.'cfg(unix)'.dependencies]
 rustix = { version = "1.1", features = ["fs", "process"] }
 
 [target.'cfg(windows)'.dependencies]
 windows-sys = { version = "0.61", features = ["Win32_Storage_FileSystem"] }
+
+[[bench]]
+name = "plugins"
+harness = false

crates/ide-host/benches/plugins.rs

@@ -0,0 +1,149 @@
+//! `cargo bench -p ide-host`: the plugin runtime budgets, checked by `pnpm perf:rust` against
+//! `perf/budgets.json` › rust (`plugins/…`).
+//!
+//! - `load_50`: start-up load of 50 installed plugins (20 with code, 10
+//!   languages with a syntax provider, 10 icon themes, 10 declarations only),
+//!   from the contribution index; no Wasm is instantiated.
+//! - `cold_activation`: an idle-reclaimed plugin's next command: activation
+//!   from the precompiled component plus the call.
+//! - `syntax_highlights_2k_lines`: an edit-path call (Solidity highlighting).
+
+use criterion::{Criterion, black_box, criterion_group, criterion_main};
+use ide_core::LanguageId;
+use ide_host::plugins::{Consent, PluginHost};
+use ide_plugin::{Invocation, Limits};
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use std::time::Duration;
+
+fn repo() -> PathBuf {
+    Path::new(env!("CARGO_MANIFEST_DIR")).join("../..").canonicalize().unwrap()
+}
+
+fn copy_dir(from: &Path, to: &Path) {
+    std::fs::create_dir_all(to).unwrap();
+    for e in std::fs::read_dir(from).unwrap().flatten() {
+        let name = e.file_name();
+        if matches!(name.to_str(), Some("target" | "src" | "Cargo.lock" | ".gitignore")) {
+            continue;
+        }
+        let dst = to.join(&name);
+        if e.path().is_dir() { copy_dir(&e.path(), &dst) } else { std::fs::copy(e.path(), &dst).map(|_| ()).unwrap() }
+    }
+}
+
+/// A copy of `src` installed under a new id (and new language / theme ids).
+fn variant(work: &Path, src: &Path, n: usize, rename: &[(&str, String)]) -> PathBuf {
+    let dir = work.join(format!("pkg{n}"));
+    copy_dir(src, &dir);
+    for file in ["plugin.toml", "languages/solidity.toml"] {
+        let path = dir.join(file);
+        if let Ok(mut text) = std::fs::read_to_string(&path) {
+            for (from, to) in rename {
+                text = text.replace(from, to);
+            }
+            std::fs::write(&path, text).unwrap();
+        }
+    }
+    dir
+}
+
+fn sink() -> Arc<dyn ide_host::plugins::PluginEventSink> {
+    Arc::new(|_: Option<&str>, _| {})
+}
+
+fn install_50(plugins: &Path, work: &Path) {
+    let host = PluginHost::new(plugins.to_path_buf(), sink(), Limits::default()).unwrap();
+    host.load_all();
+    let root = repo();
+    let mut n = 0;
+    let mut install = |src: PathBuf, rename: Vec<(&str, String)>| {
+        let pkg = variant(work, &src, n, &rename);
+        n += 1;
+        host.install_from_dir(&pkg, &Consent::default()).unwrap();
+    };
+    for i in 0..20 {
+        install(
+            root.join("crates/ide-plugin/tests/fixtures/hello"),
+            vec![("id = \"hello\"", format!("id = \"bench.hello{i}\""))],
+        );
+    }
+    for i in 0..10 {
+        install(
+            root.join("plugins/official/solidity"),
+            vec![
+                ("openidea.solidity", format!("bench.solidity{i}")),
+                ("id = \"solidity\"", format!("id = \"solidity{i}\"")),
+                ("extensions = [\"sol\"]", format!("extensions = [\"sol{i}\"]")),
+                ("on-language:solidity", format!("on-language:solidity{i}")),
+                ("id = \"forge-", format!("id = \"f{i}-")),
+                ("id = \"hardhat-", format!("id = \"h{i}-")),
+            ],
+        );
+    }
+    for i in 0..10 {
+        install(
+            root.join("plugins/official/material-icons"),
+            vec![
+                ("openidea.material-icons", format!("bench.icons{i}")),
+                ("id = \"material\"", format!("id = \"material{i}\"")),
+            ],
+        );
+    }
+    for i in 0..10 {
+        let dir = work.join(format!("static{i}"));
+        std::fs::create_dir_all(&dir).unwrap();
+        std::fs::write(
+            dir.join("plugin.toml"),
+            format!(
+                "id = \"bench.static{i}\"\nname = \"Static {i}\"\nversion = \"1.0.0\"\nengines.openidea = \"^1.0\"\n\
+                 [[contributes.commands]]\nid = \"a\"\ntitle = \"Static {i}: A\"\nwhen = \"editorLang == rust\"\n"
+            ),
+        )
+        .unwrap();
+        host.install_from_dir(&dir, &Consent::default()).unwrap();
+    }
+}
+
+fn bench(c: &mut Criterion) {
+    let tmp = tempfile::tempdir().unwrap();
+    let plugins = tmp.path().join("plugins");
+    install_50(&plugins, &tmp.path().join("work"));
+
+    let mut g = c.benchmark_group("plugins");
+    g.sample_size(20);
+    g.bench_function("load_50", |b| {
+        b.iter(|| {
+            let host = PluginHost::new(plugins.clone(), sink(), Limits::default()).unwrap();
+            host.load_all();
+            assert_eq!(host.instances(), 0, "start-up instantiates no Wasm");
+            black_box(host.list(None).plugins.len())
+        })
+    });
+
+    let limits = Limits { idle_timeout: Some(Duration::ZERO), ..Limits::default() };
+    let host = Arc::new(PluginHost::new(plugins.clone(), sink(), limits).unwrap());
+    host.load_all();
+    host.warm_component_cache();
+    g.bench_function("cold_activation", |b| {
+        b.iter(|| {
+            host.tick();
+            // Fails for want of an editor, after activating and running.
+            let r = host.run_command("bench.hello0", "word-count", None, Invocation::default());
+            black_box(r.is_err())
+        })
+    });
+
+    let provider = host.syntax_provider();
+    let lang = LanguageId::new("solidity0");
+    let unit = "contract Token {\n    uint256 public total;\n    mapping(address => uint256) balances;\n    event Sent(address to, uint256 v);\n    function send(address to, uint256 v) public returns (bool) {\n        // move funds\n        balances[to] += v;\n        emit Sent(to, v);\n        return true;\n    }\n}\n";
+    let text = unit.repeat(2000 / unit.lines().count());
+    assert!(provider.highlights(&lang, &text).is_some());
+    g.bench_function("syntax_highlights_2k_lines", |b| {
+        b.iter(|| black_box(provider.highlights(&lang, &text).map(|t| t.len())))
+    });
+    g.finish();
+}
+
+criterion_group!(benches, bench);
+criterion_main!(benches);

crates/ide-host/src/bin/openidea-plugin/main.rs

@@ -0,0 +1,988 @@
+//! `openidea-plugin`: scaffolds, builds, checks and links OpenIDEA plugins.
+//!
+//! ```text
+//! openidea-plugin new <dir> [--template command|theme|icon-theme|language] [--id ID] [--name NAME] [--sdk PATH]
+//! openidea-plugin build [dir] [--debug]   # cargo → dist/plugin.wasm, then `check`
+//! openidea-plugin check [dir|package]     # validate the package as the IDE would install it
+//! openidea-plugin link [dir]              # load the folder in the IDE without installing it
+//! openidea-plugin unlink [dir]
+//! openidea-plugin links                   # list linked folders
+//! openidea-plugin keygen <key-file>       # a publisher's Ed25519 key
+//! openidea-plugin endorse <new-public-key> --key OLD --publisher ID   # vouch for a new key
+//! openidea-plugin pack [dir] [--key F --publisher ID] [--out FILE]   # <id>-<version>.oiplugin
+//! openidea-plugin index <dir> [--publisher ID --name NAME --key F [--previous-key F]]   # marketplace index.json
+//! openidea-plugin merge <index> <other-index> --keep ID               # list another index's publishers
+//! ```
+//!
+//! `link` writes `links.json` in the IDE's plugins directory
+//! (`$OPENIDEA_PLUGINS_DIR`, or the app data directory); the IDE picks the
+//! change up when Settings › Plugins is opened or refreshed. Linked plugins
+//! are re-read from the folder, so `build` + refresh is the edit loop.
+
+mod templates;
+
+use ide_extension::{Manifest, validate_plugin_id};
+use ide_host::plugins::{PluginHost, read_market_url, resolve_market_href};
+use ide_plugin::{Limits, PluginEngine};
+use std::path::{Path, PathBuf};
+use std::process::{Command, ExitCode};
+use std::sync::Arc;
+
+const USAGE: &str = "\
+usage: openidea-plugin <command> [options]
+
+commands:
+  new <dir> [--template T] [--id ID] [--name NAME] [--sdk PATH]
+        create a plugin; T = command (default), theme, icon-theme, language. A Rust
+        plugin depends on the SDK of this tool's release (git); --sdk PATH uses a
+        local sdk/rust/openidea-plugin instead
+  build [dir] [--debug]   compile a Rust plugin to dist/plugin.wasm and check it
+  check [dir|package]     validate the package (folder or .oiplugin) as the IDE would install it
+  link [dir]              load the folder in the IDE without installing it
+  unlink [dir]            stop loading a linked folder
+  links                   list linked folders
+  keygen <key-file>       create a publisher signing key (keep the file secret)
+  endorse <new-public-key> --key F --publisher ID
+                          print an earlier key's endorsement of a new one (JSON), for an
+                          index the publisher doesn't write with `index --previous-key`
+  pack [dir] [--key F --publisher ID] [--out FILE]
+                          write <id>-<version>.oiplugin, signed with the key
+  index <dir> [--publisher ID --name NAME --key F [--previous-key F]] [--out FILE]
+        [--download-base URL]
+                          write the marketplace index.json for the packages in dir: with a
+                          key, register it and list that publisher's plugins (earlier
+                          versions stay for older IDEs); without, list only these packages,
+                          each checked against the index's publishers. A new key replacing
+                          an earlier one is endorsed with --previous-key, so installed
+                          plugins update to it without asking
+  merge <index> <other-index> --keep ID [--out FILE]
+                          replace every publisher but ID in index with those of other-index
+                          (a path or URL), their plugins and revocations
+
+environment:
+  OPENIDEA_PLUGINS_DIR    the IDE's plugins directory (default: the app data directory)";
+
+fn main() -> ExitCode {
+    let args: Vec<String> = std::env::args().skip(1).collect();
+    let result = match args.first().map(String::as_str) {
+        Some("new") => cmd_new(&args[1..]),
+        Some("build") => cmd_build(&args[1..]),
+        Some("check") => dir_arg(&args[1..]).and_then(|d| check_path(&d)),
+        Some("link") => dir_arg(&args[1..]).and_then(|d| link(&d, true)),
+        Some("unlink") => dir_arg(&args[1..]).and_then(|d| link(&d, false)),
+        Some("links") => list_links(),
+        Some("keygen") => cmd_keygen(&args[1..]),
+        Some("endorse") => cmd_endorse(&args[1..]),
+        Some("pack") => cmd_pack(&args[1..]),
+        Some("index") => cmd_index(&args[1..]),
+        Some("merge") => cmd_merge(&args[1..]),
+        Some("--version" | "-V") => {
+            println!("openidea-plugin {} (plugin API {})", env!("CARGO_PKG_VERSION"), ide_extension::ENGINE_VERSION);
+            Ok(())
+        }
+        Some("help" | "--help" | "-h") | None => {
+            println!("{USAGE}");
+            Ok(())
+        }
+        Some(other) => Err(format!("unknown command {other:?}\n\n{USAGE}")),
+    };
+    match result {
+        Ok(()) => ExitCode::SUCCESS,
+        Err(e) => {
+            eprintln!("error: {e}");
+            ExitCode::FAILURE
+        }
+    }
+}
+
+/// Splits `args` into positionals and `--flag value` / `--switch` options.
+struct Args {
+    positional: Vec<String>,
+    options: Vec<(String, Option<String>)>,
+}
+
+impl Args {
+    fn parse(args: &[String], switches: &[&str], valued: &[&str]) -> Result<Self, String> {
+        let mut out = Args { positional: Vec::new(), options: Vec::new() };
+        let mut it = args.iter();
+        while let Some(a) = it.next() {
+            if let Some(name) = a.strip_prefix("--") {
+                let (name, inline) = match name.split_once('=') {
+                    Some((n, v)) => (n, Some(v.to_owned())),
+                    None => (name, None),
+                };
+                if switches.contains(&name) && inline.is_none() {
+                    out.options.push((name.into(), None));
+                } else if valued.contains(&name) {
+                    let v = inline.or_else(|| it.next().cloned()).ok_or_else(|| format!("--{name} needs a value"))?;
+                    out.options.push((name.into(), Some(v)));
+                } else {
+                    return Err(format!("unknown option --{name}"));
+                }
+            } else {
+                out.positional.push(a.clone());
+            }
+        }
+        Ok(out)
+    }
+
+    fn value(&self, name: &str) -> Option<&str> {
+        self.options.iter().rev().find(|(n, _)| n == name).and_then(|(_, v)| v.as_deref())
+    }
+
+    fn has(&self, name: &str) -> bool {
+        self.options.iter().any(|(n, _)| n == name)
+    }
+
+    fn dir(&self) -> Result<PathBuf, String> {
+        match self.positional.as_slice() {
+            [] => Ok(PathBuf::from(".")),
+            [d] => Ok(PathBuf::from(d)),
+            _ => Err("expected at most one directory".into()),
+        }
+    }
+}
+
+fn dir_arg(args: &[String]) -> Result<PathBuf, String> {
+    Args::parse(args, &[], &[])?.dir()
+}
+
+fn canonical(dir: &Path) -> Result<PathBuf, String> {
+    dunce::canonicalize(dir).map_err(|e| format!("{}: {e}", dir.display()))
+}
+
+// ---------------------------------------------------------------- new
+
+fn cmd_new(args: &[String]) -> Result<(), String> {
+    let a = Args::parse(args, &[], &["template", "id", "name", "sdk"])?;
+    let [dir] = a.positional.as_slice() else {
+        return Err("usage: openidea-plugin new <dir> [--template T] [--id ID] [--name NAME]".into());
+    };
+    let dir = PathBuf::from(dir);
+    let template = templates::Template::parse(a.value("template").unwrap_or("command"))?;
+    let base = dir.file_name().and_then(|n| n.to_str()).ok_or("the directory needs a name")?;
+    let id = match a.value("id") {
+        Some(id) => id.to_owned(),
+        None => slugify(base),
+    };
+    validate_plugin_id(&id)?;
+    let name = match a.value("name") {
+        Some(n) => n.to_owned(),
+        None => title_case(id.rsplit('.').next().unwrap_or(&id)),
+    };
+    if name.trim().is_empty() || name.contains(['"', '\\', '\n']) {
+        return Err("--name must not be empty or contain quotes, backslashes or newlines".into());
+    }
+    if dir.exists() && std::fs::read_dir(&dir).map_err(|e| e.to_string())?.next().is_some() {
+        return Err(format!("{} already exists and is not empty", dir.display()));
+    }
+    std::fs::create_dir_all(&dir).map_err(|e| format!("{}: {e}", dir.display()))?;
+    let dir = canonical(&dir)?;
+    let sdk = match template {
+        templates::Template::Command => Some(sdk_dependency(a.value("sdk"), &dir)?),
+        _ => None,
+    };
+    let vars = templates::Vars { id: &id, name: &name, sdk: sdk.as_deref() };
+    let files = templates::render(template, &vars);
+    for (rel, content) in &files {
+        let path = dir.join(rel);
+        if let Some(parent) = path.parent() {
+            std::fs::create_dir_all(parent).map_err(|e| format!("{}: {e}", parent.display()))?;
+        }
+        std::fs::write(&path, content).map_err(|e| format!("{}: {e}", path.display()))?;
+    }
+    // Generated packages must be valid as written.
+    Manifest::load(&dir).map_err(|e| format!("internal error: the template is invalid: {e}"))?;
+    println!("created {} ({id}) in {}", template.label(), dir.display());
+    let shown = std::env::current_dir().ok().and_then(|cwd| dir.strip_prefix(cwd).ok().map(Path::to_path_buf));
+    let shown = shown.as_deref().unwrap_or(&dir).display().to_string();
+    println!();
+    println!("next:");
+    if template == templates::Template::Command {
+        println!("  cargo test --manifest-path {shown}/Cargo.toml   # unit tests against the mock host");
+        println!("  openidea-plugin build {shown}");
+    } else {
+        println!("  openidea-plugin check {shown}");
+    }
+    println!("  openidea-plugin link {shown}                  # then Settings › Plugins");
+    Ok(())
+}
+
+/// `My Cool_Plugin` → `my-cool-plugin`.
+fn slugify(s: &str) -> String {
+    let mut out = String::new();
+    for c in s.chars() {
+        match c {
+            'a'..='z' | '0'..='9' | '.' => out.push(c),
+            'A'..='Z' => out.push(c.to_ascii_lowercase()),
+            _ if !out.ends_with('-') && !out.is_empty() => out.push('-'),
+            _ => {}
+        }
+    }
+    out.trim_matches(['-', '.']).to_owned()
+}
+
+/// `my-cool_plugin` → `My Cool Plugin`.
+fn title_case(s: &str) -> String {
+    s.split(['-', '_'])
+        .filter(|w| !w.is_empty())
+        .map(|w| {
+            let mut c = w.chars();
+            c.next().map(|f| f.to_uppercase().chain(c).collect::<String>()).unwrap_or_default()
+        })
+        .collect::<Vec<_>>()
+        .join(" ")
+}
+
+/// The SDK dependency written into a new plugin's Cargo.toml: by path with `--sdk`, or
+/// when the plugin is inside the source tree this tool was built from; otherwise the
+/// repository at this tool's release tag.
+fn sdk_dependency(explicit: Option<&str>, plugin_dir: &Path) -> Result<String, String> {
+    let sdk = match explicit {
+        Some(p) => PathBuf::from(p),
+        None => match dunce::canonicalize(concat!(env!("CARGO_MANIFEST_DIR"), "/../..")) {
+            Ok(tree) if plugin_dir.starts_with(&tree) => tree.join("sdk/rust/openidea-plugin"),
+            _ => return Ok(format!("{{ git = \"{REPOSITORY}\", tag = \"v{}\" }}", env!("CARGO_PKG_VERSION"))),
+        },
+    };
+    let sdk = dunce::canonicalize(&sdk).map_err(|_| {
+        format!("the plugin SDK was not found at {}; pass --sdk <path to sdk/rust/openidea-plugin>", sdk.display())
+    })?;
+    if !sdk.join("Cargo.toml").is_file() {
+        return Err(format!("{} is not the openidea-plugin SDK (no Cargo.toml)", sdk.display()));
+    }
+    let path = relative(plugin_dir, &sdk).unwrap_or(sdk);
+    Ok(format!("{{ path = \"{}\" }}", path.to_string_lossy().replace('\\', "/")))
+}
+
+const REPOSITORY: &str = "https://github.com/l0ng-ai/openidea";
+
+/// `to` relative to `from` when they share a root (keeps packages in a repo movable).
+fn relative(from: &Path, to: &Path) -> Option<PathBuf> {
+    let (f, t): (Vec<_>, Vec<_>) = (from.components().collect(), to.components().collect());
+    let common = f.iter().zip(&t).take_while(|(a, b)| a == b).count();
+    if common <= 1 {
+        return None;
+    }
+    let mut out = PathBuf::new();
+    for _ in common..f.len() {
+        out.push("..");
+    }
+    for c in &t[common..] {
+        out.push(c);
+    }
+    Some(out)
+}
+
+// ---------------------------------------------------------------- build / check
+
+fn cmd_build(args: &[String]) -> Result<(), String> {
+    let a = Args::parse(args, &["debug"], &[])?;
+    let dir = canonical(&a.dir()?)?;
+    let manifest = Manifest::load(&dir)?;
+    let cargo_toml = dir.join("Cargo.toml");
+    if !cargo_toml.is_file() {
+        if manifest.wasm.is_some() {
+            return Err(format!(
+                "{} has no Cargo.toml: build the component with your toolchain, then run `check`",
+                dir.display()
+            ));
+        }
+        println!("{} has no code to build", manifest.id);
+        return check(&dir);
+    }
+    let wasm_rel = manifest.wasm.clone().ok_or("plugin.toml has no `wasm = \"dist/plugin.wasm\"`")?;
+    let crate_name = crate_name(&cargo_toml)?;
+    ensure_wasm_target();
+    let release = !a.has("debug");
+    let target_dir = std::env::var_os("CARGO_TARGET_DIR").map(PathBuf::from).unwrap_or_else(|| dir.join("target"));
+    let mut cmd = Command::new(std::env::var_os("CARGO").unwrap_or_else(|| "cargo".into()));
+    cmd.arg("build").arg("--manifest-path").arg(&cargo_toml).args(["--target", "wasm32-wasip2"]);
+    if release {
+        cmd.arg("--release");
+    }
+    cmd.env("CARGO_TARGET_DIR", &target_dir);
+    println!("building {crate_name} for wasm32-wasip2 ({})", if release { "release" } else { "debug" });
+    let status = cmd.status().map_err(|e| format!("cannot run cargo: {e}"))?;
+    if !status.success() {
+        return Err("cargo build failed".into());
+    }
+    let built = target_dir
+        .join("wasm32-wasip2")
+        .join(if release { "release" } else { "debug" })
+        .join(format!("{}.wasm", crate_name.replace('-', "_")));
+    if !built.is_file() {
+        return Err(format!("{} was not produced: is `crate-type = [\"cdylib\"]` set in Cargo.toml?", built.display()));
+    }
+    let out = dir.join(&wasm_rel);
+    if let Some(parent) = out.parent() {
+        std::fs::create_dir_all(parent).map_err(|e| format!("{}: {e}", parent.display()))?;
+    }
+    std::fs::copy(&built, &out).map_err(|e| format!("{}: {e}", out.display()))?;
+    let size = std::fs::metadata(&out).map(|m| m.len()).unwrap_or(0);
+    println!("  -> {} ({})", wasm_rel.display(), human_size(size));
+    check(&dir)
+}
+
+fn crate_name(cargo_toml: &Path) -> Result<String, String> {
+    let src = std::fs::read_to_string(cargo_toml).map_err(|e| format!("{}: {e}", cargo_toml.display()))?;
+    let doc: toml::Table = src.parse().map_err(|e| format!("{}: {e}", cargo_toml.display()))?;
+    let package = doc.get("package").and_then(|p| p.as_table());
+    let lib_name = doc.get("lib").and_then(|l| l.get("name")).and_then(|n| n.as_str());
+    lib_name
+        .or_else(|| package.and_then(|p| p.get("name")).and_then(|n| n.as_str()))
+        .map(str::to_owned)
+        .ok_or_else(|| format!("{}: no [package] name", cargo_toml.display()))
+}
+
+/// Installs the target through rustup when it is missing (no-op without rustup).
+fn ensure_wasm_target() {
+    let Ok(out) = Command::new("rustup").args(["target", "list", "--installed"]).output() else { return };
+    if String::from_utf8_lossy(&out.stdout).lines().any(|l| l.trim() == "wasm32-wasip2") {
+        return;
+    }
+    println!("installing the wasm32-wasip2 target");
+    let _ = Command::new("rustup").args(["target", "add", "wasm32-wasip2"]).status();
+}
+
+/// Validates `dir` exactly as Install from Disk would, and checks the
+/// component imports only the plugin API.
+/// [`check`] of a folder, or of a package file unpacked as installing would.
+fn check_path(path: &Path) -> Result<(), String> {
+    if !path.is_file() {
+        return check(path);
+    }
+    let tmp = scratch_dir("unpack")?;
+    let dir = tmp.path().join("package");
+    package::unpack(path, &dir).and_then(|_| check(&dir))
+}
+
+fn check(dir: &Path) -> Result<(), String> {
+    let dir = canonical(dir)?;
+    let tmp = scratch_dir("check")?;
+    let scratch = tmp.path().join("host");
+    (|| {
+        let host = PluginHost::new(scratch.clone(), Arc::new(|_: Option<&str>, _| {}), Limits::default())
+            .map_err(|e| e.to_string())?;
+        let preview = host.preview_install(&dir).map_err(|e| e.to_string())?;
+        let manifest = Manifest::load(&dir)?;
+        println!("{} {} — {}", preview.id, preview.version, preview.name);
+        if manifest.legacy {
+            println!("  note: plugin.toml uses the 0.1 format (`openidea-api`); see plugins/README.md to move to 0.2");
+        }
+        if let Some(wasm) = &manifest.wasm {
+            let engine = PluginEngine::new()?;
+            let component = engine.compile(&dir.join(wasm))?;
+            let built_for = engine.check_component(&component)?;
+            let size = std::fs::metadata(dir.join(wasm)).map(|m| m.len()).unwrap_or(0);
+            let api = built_for.map(|v| format!(", plugin API {}.{}", v.major, v.minor)).unwrap_or_default();
+            println!("  code: {} ({}{api})", wasm.display(), human_size(size));
+        } else {
+            println!("  code: none (contributions only)");
+        }
+        println!("  categories: {}", manifest.categories().join(", "));
+        for c in manifest.unknown_categories() {
+            println!("  warning: unknown category {c:?} (ignored); use {}", ide_extension::CATEGORIES.join(", "));
+        }
+        if manifest.declared_categories.len() > ide_extension::MAX_CATEGORIES {
+            println!(
+                "  warning: only the first {} known categories are used; {} are declared",
+                ide_extension::MAX_CATEGORIES,
+                manifest.declared_categories.len()
+            );
+        }
+        if !manifest.activation.is_empty() {
+            let events: Vec<String> = manifest.activation.iter().map(ToString::to_string).collect();
+            println!("  activation: {}", events.join(", "));
+        }
+        for c in &preview.contributions {
+            println!("  contributes {} × {}", c.count, c.point);
+        }
+        for c in &preview.capabilities {
+            let kind = if c.optional { "optional" } else { "required" };
+            println!("  capability {} ({kind}, {:?} risk): {}", c.id, c.risk, c.description);
+        }
+        for w in &preview.warnings {
+            println!("  warning: {w}");
+        }
+        println!("ok");
+        Ok(())
+    })()
+}
+
+fn human_size(bytes: u64) -> String {
+    match bytes {
+        b if b >= 1 << 20 => format!("{:.1} MiB", b as f64 / (1 << 20) as f64),
+        b if b >= 1 << 10 => format!("{:.1} KiB", b as f64 / 1024.0),
+        b => format!("{b} B"),
+    }
+}
+
+// ---------------------------------------------------------------- link
+
+fn plugins_dir() -> Result<PathBuf, String> {
+    if let Some(dir) = std::env::var_os("OPENIDEA_PLUGINS_DIR") {
+        return Ok(PathBuf::from(dir));
+    }
+    dirs::data_dir()
+        .map(|d| d.join("ai.l0ng.openidea").join("plugins"))
+        .ok_or_else(|| "cannot find the app data directory; set OPENIDEA_PLUGINS_DIR".into())
+}
+
+#[derive(Default, serde::Serialize, serde::Deserialize)]
+struct Links {
+    #[serde(default)]
+    paths: Vec<PathBuf>,
+}
+
+fn read_links(file: &Path) -> Result<Links, String> {
+    match std::fs::read_to_string(file) {
+        Ok(s) => serde_json::from_str(&s).map_err(|e| format!("{}: {e}", file.display())),
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(Links::default()),
+        Err(e) => Err(format!("{}: {e}", file.display())),
+    }
+}
+
+fn link(dir: &Path, add: bool) -> Result<(), String> {
+    let plugins = plugins_dir()?;
+    let file = plugins.join("links.json");
+    let mut links = read_links(&file)?;
+    let dir = if add {
+        let dir = canonical(dir)?;
+        let m = Manifest::load(&dir)?;
+        if let Some(wasm) = &m.wasm
+            && !dir.join(wasm).is_file()
+        {
+            println!("note: {} does not exist yet; run `openidea-plugin build` first", wasm.display());
+        }
+        if links.paths.contains(&dir) {
+            println!("{} is already linked", dir.display());
+            return Ok(());
+        }
+        println!("linked {} ({})", m.id, dir.display());
+        links.paths.push(dir.clone());
+        dir
+    } else {
+        let dir = dunce::canonicalize(dir).unwrap_or_else(|_| dir.to_path_buf());
+        let before = links.paths.len();
+        links.paths.retain(|p| p != &dir);
+        if links.paths.len() == before {
+            return Err(format!("{} is not linked", dir.display()));
+        }
+        println!("unlinked {}", dir.display());
+        dir
+    };
+    let _ = dir;
+    std::fs::create_dir_all(&plugins).map_err(|e| format!("{}: {e}", plugins.display()))?;
+    let json = serde_json::to_string_pretty(&links).map_err(|e| e.to_string())?;
+    let tmp = file.with_extension("json.tmp");
+    std::fs::write(&tmp, json)
+        .and_then(|()| std::fs::rename(&tmp, &file))
+        .map_err(|e| format!("{}: {e}", file.display()))?;
+    println!("open Settings › Plugins in OpenIDEA to load the change");
+    Ok(())
+}
+
+fn list_links() -> Result<(), String> {
+    let links = read_links(&plugins_dir()?.join("links.json"))?;
+    if links.paths.is_empty() {
+        println!("no linked plugins");
+    }
+    for p in links.paths {
+        let id = Manifest::load(&p).map(|m| m.id).unwrap_or_else(|e| format!("invalid: {e}"));
+        println!("{id}\t{}", p.display());
+    }
+    Ok(())
+}
+
+// ---------------------------------------------------------------- distribution
+
+use ide_extension::package::{self, Index, IndexEntry, KeyEntry, PublisherKey};
+
+fn read_key(path: &str) -> Result<PublisherKey, String> {
+    PublisherKey::from_base64(&std::fs::read_to_string(path).map_err(|e| format!("{path}: {e}"))?)
+}
+
+fn cmd_keygen(args: &[String]) -> Result<(), String> {
+    let a = Args::parse(args, &[], &[])?;
+    let [file] = a.positional.as_slice() else { return Err("usage: openidea-plugin keygen <key-file>".into()) };
+    if Path::new(file).exists() {
+        return Err(format!("{file} exists; not overwriting a key"));
+    }
+    let mut seed = [0u8; 32];
+    getrandom::fill(&mut seed).map_err(|e| format!("random: {e}"))?;
+    let key = PublisherKey::from_seed(seed);
+    std::fs::write(file, key.seed_base64()).map_err(|e| format!("{file}: {e}"))?;
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        let _ = std::fs::set_permissions(file, std::fs::Permissions::from_mode(0o600));
+    }
+    println!("public key: {}", key.public_base64());
+    println!("register it with your publisher id in the marketplace index; keep {file} secret");
+    Ok(())
+}
+
+fn cmd_endorse(args: &[String]) -> Result<(), String> {
+    let a = Args::parse(args, &[], &["key", "publisher"])?;
+    let usage = "usage: openidea-plugin endorse <new-public-key> --key <earlier-key-file> --publisher ID";
+    let ([new], Some(key), Some(publisher)) = (a.positional.as_slice(), a.value("key"), a.value("publisher")) else {
+        return Err(usage.into());
+    };
+    if !package::publisher_id_ok(publisher) {
+        return Err(format!("invalid publisher id {publisher:?}"));
+    }
+    let endorsement = read_key(key)?.endorse(publisher, new.trim());
+    println!("{}", serde_json::to_string_pretty(&endorsement).map_err(|e| e.to_string())?);
+    Ok(())
+}
+
+/// A fresh scratch directory, removed when dropped.
+fn scratch_dir(what: &str) -> Result<tempfile::TempDir, String> {
+    tempfile::Builder::new().prefix(&format!("openidea-plugin-{what}-")).tempdir().map_err(|e| e.to_string())
+}
+
+/// A scratch host to list a package's files as the IDE would.
+fn with_scratch_host<T>(f: impl FnOnce(&PluginHost) -> Result<T, String>) -> Result<T, String> {
+    let tmp = scratch_dir("host")?;
+    PluginHost::new(tmp.path().join("host"), Arc::new(|_: Option<&str>, _| {}), Limits::default())
+        .map_err(|e| e.to_string())
+        .and_then(|h| f(&h))
+}
+
+fn cmd_pack(args: &[String]) -> Result<(), String> {
+    let a = Args::parse(args, &[], &["key", "publisher", "out"])?;
+    let dir = canonical(&a.dir()?)?;
+    check(&dir)?;
+    let manifest = Manifest::load(&dir)?;
+    let mut files = with_scratch_host(|h| h.package_files_of(&dir).map_err(|e| e.to_string()))?;
+    let digest = package::package_digest(&dir, &files).map_err(|e| e.to_string())?;
+    let signature = match (a.value("key"), a.value("publisher")) {
+        (Some(key), Some(publisher)) => {
+            if !manifest.id.starts_with(&format!("{publisher}.")) {
+                return Err(format!("publisher {publisher:?} may only sign plugins named {publisher}.*"));
+            }
+            Some(read_key(key)?.sign(publisher, &manifest.id, &manifest.version, &digest))
+        }
+        (None, None) => None,
+        _ => return Err("--key and --publisher go together".into()),
+    };
+    for lic in ["LICENSE", "LICENSE.md", "LICENSE.txt", "NOTICE", "NOTICE.md", "COPYING", "README.md"] {
+        if dir.join(lic).is_file() {
+            files.push(PathBuf::from(lic));
+        }
+    }
+    let out = a.value("out").map(PathBuf::from).unwrap_or_else(|| {
+        PathBuf::from(format!("{}-{}.{}", manifest.id, manifest.version, package::PACKAGE_EXTENSION))
+    });
+    package::pack(&dir, &files, &out, signature.as_ref())?;
+    let size = std::fs::metadata(&out).map(|m| m.len()).unwrap_or(0);
+    let signed = signature.as_ref().map_or("unsigned".to_owned(), |s| format!("signed by {}", s.publisher));
+    println!("-> {} ({}, {signed})", out.display(), human_size(size));
+    Ok(())
+}
+
+fn cmd_index(args: &[String]) -> Result<(), String> {
+    let a = Args::parse(args, &[], &["publisher", "name", "key", "previous-key", "out", "download-base"])?;
+    let dir = canonical(&a.dir()?)?;
+    let out = a.value("out").map(PathBuf::from).unwrap_or_else(|| dir.join("index.json"));
+    let base = a.value("download-base").map(|b| b.trim_end_matches('/'));
+    // Revocations and other publishers of an existing index are kept.
+    let mut index = match std::fs::read_to_string(&out) {
+        Ok(text) => current_format(Index::parse(&text)?, &out.to_string_lossy())?,
+        Err(_) => Index { format: package::INDEX_FORMAT, ..Index::default() },
+    };
+    let publisher = match (a.value("publisher"), a.value("key")) {
+        (Some(publisher), Some(key)) => {
+            let key = read_key(key)?;
+            let name = a.value("name").unwrap_or(publisher);
+            let previous = a.value("previous-key").map(read_key).transpose()?;
+            index.publishers =
+                register_key(std::mem::take(&mut index.publishers), publisher, name, &key, previous.as_ref())?;
+            Some(publisher)
+        }
+        (None, None) if a.has("previous-key") => return Err("--previous-key goes with --publisher and --key".into()),
+        (None, None) => None,
+        _ => return Err("--publisher and --key go together".into()),
+    };
+    let mut packages: Vec<PathBuf> = std::fs::read_dir(&dir)
+        .map_err(|e| e.to_string())?
+        .flatten()
+        .map(|e| e.path())
+        .filter(|p| p.extension().is_some_and(|e| e == package::PACKAGE_EXTENSION))
+        .collect();
+    packages.sort();
+    let engine = PluginEngine::new()?;
+    let mut added: Vec<IndexEntry> = Vec::new();
+    for path in packages {
+        let tmp = scratch_dir("index")?;
+        let scratch = tmp.path().join("package");
+        let entry = (|| {
+            let unpacked = package::unpack(&path, &scratch)?;
+            let m = Manifest::load(&scratch)?;
+            let files = with_scratch_host(|h| h.package_files_of(&scratch).map_err(|e| e.to_string()))?;
+            let digest = package::package_digest(&scratch, &files).map_err(|e| e.to_string())?;
+            let sig = unpacked.signature.as_ref().ok_or("not signed")?;
+            let signer = index.verify(sig, &m.id, &m.version, &digest)?;
+            if publisher.is_some_and(|p| p != signer) {
+                return Err(format!("signed by {signer}, not {}", publisher.unwrap_or_default()));
+            }
+            if added.iter().any(|e| (&e.id, &e.version) == (&m.id, &m.version)) {
+                return Err(format!("another package of {} {} is in the folder", m.id, m.version));
+            }
+            if m.legacy {
+                return Err("plugin.toml uses the 0.1 format; see plugins/README.md".into());
+            }
+            let built_for = match &m.wasm {
+                Some(wasm) => engine.check_component(&engine.compile(&scratch.join(wasm))?)?,
+                None => None,
+            };
+            let file = path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
+            Ok::<_, String>(IndexEntry {
+                id: m.id.clone(),
+                name: m.name.clone(),
+                version: m.version.clone(),
+                description: m.description.clone(),
+                authors: m.authors.clone(),
+                publisher: signer,
+                download: base.map_or_else(|| file.clone(), |b| format!("{b}/{file}")),
+                digest,
+                capabilities: m.capabilities.all().map(|c| c.to_string()).collect(),
+                engine: package::engine_requirement(&m.engine, built_for.as_ref()),
+                categories: m.categories(),
+            })
+        })();
+        let entry = entry.map_err(|e| format!("{}: {e}", path.display()))?;
+        println!("  {} {} (plugin API {})", entry.id, entry.version, entry.engine);
+        added.push(entry);
+    }
+    // A publisher's earlier versions of these plugins stay for IDEs that can't load the new
+    // ones (pruned below); plugins no longer in the folder go.
+    index.plugins.retain(|e| match publisher {
+        Some(p) => {
+            e.publisher != p
+                || (added.iter().any(|n| n.id == e.id)
+                    && !added.iter().any(|n| (&n.id, &n.version) == (&e.id, &e.version)))
+        }
+        None => false,
+    });
+    index.plugins.extend(added);
+    index.prune_versions();
+    write_index(&index, &out)
+}
+
+/// `publishers` with `key` as `publisher`'s current key. Earlier keys stay listed
+/// (packages they signed remain valid until revoked); a key new to the
+/// publisher is endorsed by `previous`, one of them, so installed plugins
+/// signed with it update without asking.
+fn register_key(
+    mut publishers: Vec<package::Publisher>,
+    publisher: &str,
+    name: &str,
+    key: &PublisherKey,
+    previous: Option<&PublisherKey>,
+) -> Result<Vec<package::Publisher>, String> {
+    let current = key.public_base64();
+    let earlier: Vec<KeyEntry> = publishers.iter().filter(|p| p.id == publisher).flat_map(|p| p.keys.clone()).collect();
+    let entry = match earlier.iter().find(|k| k.key == current) {
+        Some(listed) => listed.clone(),
+        None => {
+            let endorsement = match previous {
+                Some(prev) => {
+                    let prev_key = prev.public_base64();
+                    if !earlier.iter().any(|k| k.key == prev_key && !k.revoked) {
+                        return Err(format!("--previous-key is not one of {publisher}'s valid keys in the index"));
+                    }
+                    Some(prev.endorse(publisher, &current))
+                }
+                None => {
+                    if earlier.iter().any(|k| !k.revoked) {
+                        println!(
+                            "  warning: {publisher}'s new key is not endorsed (--previous-key): users who installed \
+                             its plugins will be asked to confirm the change when they update"
+                        );
+                    }
+                    None
+                }
+            };
+            KeyEntry { endorsement, ..KeyEntry::new(current.clone()) }
+        }
+    };
+    let keys = std::iter::once(entry).chain(earlier.into_iter().filter(|k| k.key != current)).collect();
+    publishers.retain(|p| p.id != publisher);
+    publishers.push(package::Publisher { id: publisher.into(), name: name.into(), keys });
+    Ok(publishers)
+}
+
+/// `index`, unless a newer `openidea-plugin` wrote it (rewriting it would drop what this one can't read).
+fn current_format(index: Index, file: &str) -> Result<Index, String> {
+    if index.is_newer() {
+        return Err(format!(
+            "{file}: index format {} is newer than this tool writes; update openidea-plugin",
+            index.format
+        ));
+    }
+    Ok(index)
+}
+
+fn cmd_merge(args: &[String]) -> Result<(), String> {
+    let a = Args::parse(args, &[], &["keep", "out"])?;
+    let [base, other] = a.positional.as_slice() else {
+        return Err("usage: openidea-plugin merge <index> <other-index> --keep ID [--out FILE]".into());
+    };
+    let keep = a.value("keep").ok_or("--keep is required")?;
+    let out = a.value("out").unwrap_or(base);
+    let mut index =
+        current_format(Index::parse(&std::fs::read_to_string(base).map_err(|e| format!("{base}: {e}"))?)?, base)?;
+    let bytes = read_market_url(other, 16 << 20)?;
+    let theirs = Index::parse(&String::from_utf8(bytes).map_err(|_| format!("{other}: not UTF-8"))?)?;
+    let mut theirs = current_format(theirs, other)?;
+    // Their downloads are relative to their index, not to ours.
+    for e in &mut theirs.plugins {
+        e.download = resolve_market_href(other, &e.download);
+    }
+    let count = theirs.plugins.len();
+    index.include(theirs, &[keep]).map_err(|e| format!("{other}: {e}"))?;
+    println!("  {count} plugins from {other}");
+    write_index(&index, Path::new(out))
+}
+
+fn write_index(index: &Index, out: &Path) -> Result<(), String> {
+    let json = serde_json::to_string_pretty(index).map_err(|e| e.to_string())?;
+    std::fs::write(out, json).map_err(|e| format!("{}: {e}", out.display()))?;
+    println!("-> {} ({} plugins)", out.display(), index.plugins.len());
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_new_key_is_endorsed_by_the_previous_one() {
+        let (k1, k2, k3) =
+            (PublisherKey::from_seed([1; 32]), PublisherKey::from_seed([2; 32]), PublisherKey::from_seed([3; 32]));
+        let first = register_key(Vec::new(), "acme", "ACME", &k1, None).unwrap();
+        let rotated = register_key(first.clone(), "acme", "ACME", &k2, Some(&k1)).unwrap();
+        let index = Index { format: package::INDEX_FORMAT, publishers: rotated.clone(), ..Index::default() };
+        assert!(index.succeeds("acme", &k1.public_base64(), &k2.public_base64()));
+        assert_eq!(rotated[0].keys.len(), 2, "the earlier key stays listed");
+        // Registering the current key again keeps its endorsement.
+        let again = register_key(rotated.clone(), "acme", "ACME", &k2, None).unwrap();
+        assert_eq!(again, rotated);
+        // Only a key the publisher has can endorse.
+        assert!(register_key(first.clone(), "acme", "ACME", &k2, Some(&k3)).unwrap_err().contains("--previous-key"));
+        // Without one the new key is listed unendorsed.
+        let unendorsed = register_key(first, "acme", "ACME", &k3, None).unwrap();
+        assert!(unendorsed[0].keys[0].endorsement.is_none());
+    }
+
+    #[test]
+    fn names() {
+        assert_eq!(slugify("My Cool_Plugin"), "my-cool-plugin");
+        assert_eq!(slugify("acme.Tools"), "acme.tools");
+        assert_eq!(title_case("material-icons"), "Material Icons");
+        assert_eq!(
+            relative(Path::new("/a/b/plugins/x"), Path::new("/a/b/sdk/rust/p")).unwrap(),
+            PathBuf::from("../../sdk/rust/p")
+        );
+        assert_eq!(relative(Path::new("/x/y"), Path::new("/z")), None);
+    }
+
+    #[test]
+    fn new_plugins_depend_on_the_sdk_by_path_only_in_its_source_tree() {
+        let tree = dunce::canonicalize(concat!(env!("CARGO_MANIFEST_DIR"), "/../..")).unwrap();
+        assert_eq!(
+            sdk_dependency(None, &tree.join("plugins/official/new")).unwrap(),
+            "{ path = \"../../../sdk/rust/openidea-plugin\" }"
+        );
+        let outside = dunce::canonicalize(std::env::temp_dir()).unwrap().join("my-plugin");
+        assert_eq!(
+            sdk_dependency(None, &outside).unwrap(),
+            format!("{{ git = \"https://github.com/l0ng-ai/openidea\", tag = \"v{}\" }}", env!("CARGO_PKG_VERSION"))
+        );
+        let sdk = tree.join("sdk/rust/openidea-plugin");
+        assert!(sdk_dependency(Some(sdk.to_str().unwrap()), &outside).unwrap().starts_with("{ path = "));
+        assert!(
+            sdk_dependency(Some(tree.join("wit").to_str().unwrap()), &outside)
+                .unwrap_err()
+                .contains("not the openidea-plugin SDK")
+        );
+    }
+
+    /// A theme package `id` signed by `publisher` with `key`, packed into `out`.
+    fn signed_theme(tmp: &Path, id: &str, publisher: &str, key: &str, out: &Path) {
+        signed_theme_version(tmp, id, "0.1.0", "^1.0", publisher, key, out);
+    }
+
+    fn signed_theme_version(tmp: &Path, id: &str, version: &str, engine: &str, publisher: &str, key: &str, out: &Path) {
+        let src = tmp.join("src").join(format!("{id}-{version}"));
+        let vars = templates::Vars { id, name: id, sdk: None };
+        for (rel, content) in templates::render(templates::Template::Theme, &vars) {
+            let path = src.join(rel);
+            std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+            let content = content
+                .replace("version = \"0.1.0\"", &format!("version = \"{version}\""))
+                .replace("engines.openidea = \"^1.0\"", &format!("engines.openidea = \"{engine}\""));
+            std::fs::write(path, content).unwrap();
+        }
+        std::fs::create_dir_all(out).unwrap();
+        let args = [src.to_str().unwrap(), "--key", key, "--publisher", publisher, "--out"]
+            .into_iter()
+            .map(String::from)
+            .chain([out.join(format!("{id}-{version}.oiplugin")).to_string_lossy().into_owned()])
+            .collect::<Vec<_>>();
+        cmd_pack(&args).unwrap();
+    }
+
+    #[test]
+    fn a_release_keeps_the_versions_older_ides_need() {
+        let tmp = tempfile::tempdir().unwrap();
+        let t = tmp.path();
+        let key = t.join("acme.key");
+        std::fs::write(&key, PublisherKey::from_seed([5; 32]).seed_base64()).unwrap();
+        let key = key.to_string_lossy().into_owned();
+        let index_file = t.join("index.json");
+        let release = |n: usize, packages: &[(&str, &str, &str)]| {
+            let dir = t.join(format!("release-{n}"));
+            for (id, version, engine) in packages {
+                signed_theme_version(t, id, version, engine, "acme", &key, &dir);
+            }
+            let base = format!("https://example.com/download/v{n}");
+            let args = [dir.to_str().unwrap(), "--publisher", "acme", "--key", &key, "--download-base", &base];
+            cmd_index(&strings(&[&args[..], &["--out", index_file.to_str().unwrap()]].concat())).unwrap();
+            let index = Index::parse(&std::fs::read_to_string(&index_file).unwrap()).unwrap();
+            index.plugins.iter().map(|e| format!("{} {} {}", e.id, e.version, e.download)).collect::<Vec<_>>()
+        };
+        release(1, &[("acme.a", "1.0.0", "^1.0"), ("acme.b", "1.0.0", "^1.0")]);
+        // Same requirement: the newer version replaces it; acme.b is gone from the release.
+        assert_eq!(
+            release(2, &[("acme.a", "1.1.0", "^1.0")]),
+            ["acme.a 1.1.0 https://example.com/download/v2/acme.a-1.1.0.oiplugin"]
+        );
+        // Another API requirement: the last version for the earlier one stays, where it was published.
+        assert_eq!(
+            release(3, &[("acme.a", "2.0.0", ">=1.0, <2")]),
+            [
+                "acme.a 1.1.0 https://example.com/download/v2/acme.a-1.1.0.oiplugin",
+                "acme.a 2.0.0 https://example.com/download/v3/acme.a-2.0.0.oiplugin",
+            ]
+        );
+        let index = Index::parse(&std::fs::read_to_string(&index_file).unwrap()).unwrap();
+        assert_eq!(index.offered()[0].0.version, "2.0.0", "the newest this IDE can load");
+    }
+
+    fn strings(args: &[&str]) -> Vec<String> {
+        args.iter().map(|a| a.to_string()).collect()
+    }
+
+    #[test]
+    fn official_and_community_indexes_merge() {
+        let tmp = tempfile::tempdir().unwrap();
+        let t = tmp.path();
+        let mut keys = Vec::new();
+        for (name, seed) in [("openidea", 1), ("alice", 2), ("carol", 3)] {
+            let file = t.join(format!("{name}.key"));
+            let key = PublisherKey::from_seed([seed; 32]);
+            std::fs::write(&file, key.seed_base64()).unwrap();
+            keys.push((file.to_string_lossy().into_owned(), key.public_base64()));
+        }
+        let (official, community) = (t.join("official"), t.join("community"));
+        signed_theme(t, "openidea.night", "openidea", &keys[0].0, &official);
+        signed_theme(t, "alice.dawn", "alice", &keys[1].0, &community);
+        let official_index = official.join("index.json");
+        let community_index = community.join("index.json");
+        let release = strings(&[official.to_str().unwrap(), "--publisher", "openidea", "--key", &keys[0].0]);
+        cmd_index(&release).unwrap();
+
+        // The community index lists its publishers; `index` without a key checks packages against them.
+        let skeleton = Index {
+            format: package::INDEX_FORMAT,
+            publishers: vec![package::Publisher {
+                id: "alice".into(),
+                name: "Alice".into(),
+                keys: vec![KeyEntry::new(keys[1].1.clone())],
+            }],
+            ..Index::default()
+        };
+        write_index(&skeleton, &community_index).unwrap();
+        cmd_index(&strings(&[community.to_str().unwrap()])).unwrap();
+
+        cmd_merge(&strings(&[
+            official_index.to_str().unwrap(),
+            community_index.to_str().unwrap(),
+            "--keep",
+            "openidea",
+        ]))
+        .unwrap();
+        // A release rebuilds the official plugins and keeps the community's.
+        cmd_index(&release).unwrap();
+        let index = Index::parse(&std::fs::read_to_string(&official_index).unwrap()).unwrap();
+        let listed: Vec<_> = index.plugins.iter().map(|e| (e.id.as_str(), e.publisher.as_str())).collect();
+        assert_eq!(listed, [("alice.dawn", "alice"), ("openidea.night", "openidea")]);
+        assert_eq!(index.plugins[1].categories, ["themes"], "implied by the theme");
+        assert_eq!(index.plugins[1].download, "openidea.night-0.1.0.oiplugin");
+        assert!(Path::new(&index.plugins[0].download).is_absolute(), "{}", index.plugins[0].download);
+
+        // A package by a publisher the index doesn't know is refused.
+        signed_theme(t, "carol.noon", "carol", &keys[2].0, &community);
+        let err = cmd_index(&strings(&[community.to_str().unwrap()])).unwrap_err();
+        assert!(err.contains("unknown publisher"), "{err}");
+    }
+
+    /// `cargo test` of a new Rust plugin (its own tests against the mock host) with this SDK.
+    #[test]
+    fn the_command_template_builds_against_the_sdk() {
+        let dir = std::env::temp_dir().join(format!("openidea-plugin-template-build-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+        let dir = dunce::canonicalize(&dir).unwrap();
+        let plugin = dir.join("plugin");
+        let sdk = concat!(env!("CARGO_MANIFEST_DIR"), "/../../sdk/rust/openidea-plugin");
+        let sdk = sdk_dependency(Some(sdk), &plugin).unwrap();
+        let vars = templates::Vars { id: "acme.sample", name: "Sample", sdk: Some(&sdk) };
+        for (rel, content) in templates::render(templates::Template::Command, &vars) {
+            let path = plugin.join(rel);
+            std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+            std::fs::write(path, content).unwrap();
+        }
+        // The SDK's lockfile keeps the versions its own CI builds with (the resolver also
+        // looks up the wasm-only dependencies, which may not be downloaded yet).
+        let sdk_lock = concat!(env!("CARGO_MANIFEST_DIR"), "/../../sdk/rust/openidea-plugin/Cargo.lock");
+        std::fs::copy(sdk_lock, plugin.join("Cargo.lock")).unwrap();
+        let out = Command::new(std::env::var("CARGO").unwrap_or_else(|_| "cargo".into()))
+            .args(["test", "--manifest-path"])
+            .arg(plugin.join("Cargo.toml"))
+            .env("CARGO_TARGET_DIR", dir.join("target"))
+            .output()
+            .unwrap();
+        assert!(
+            out.status.success(),
+            "{}{}",
+            String::from_utf8_lossy(&out.stdout),
+            String::from_utf8_lossy(&out.stderr)
+        );
+        std::fs::remove_dir_all(&dir).unwrap();
+    }
+
+    #[test]
+    fn every_template_is_a_valid_package() {
+        for t in templates::Template::ALL {
+            let dir =
+                std::env::temp_dir().join(format!("openidea-plugin-template-{}-{}", t.label(), std::process::id()));
+            let _ = std::fs::remove_dir_all(&dir);
+            let vars = templates::Vars { id: "acme.sample", name: "Sample", sdk: Some("{ path = \"../sdk\" }") };
+            for (rel, content) in templates::render(t, &vars) {
+                let path = dir.join(rel);
+                std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+                std::fs::write(path, content).unwrap();
+            }
+            let m = Manifest::load(&dir).unwrap_or_else(|e| panic!("{}: {e}", t.label()));
+            assert_eq!(m.id, "acme.sample");
+            if m.wasm.is_none() {
+                check(&dir).unwrap_or_else(|e| panic!("{}: {e}", t.label()));
+            }
+            std::fs::remove_dir_all(&dir).unwrap();
+        }
+    }
+}

crates/ide-host/src/bin/openidea-plugin/templates.rs

@@ -0,0 +1,282 @@
+//! The files of `openidea-plugin new`. Placeholders: `__ID__` (plugin id),
+//! `__SLUG__` (last id segment), `__NAME__`, `__CRATE__`, `__SDK__`.
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Template {
+    Command,
+    Theme,
+    IconTheme,
+    Language,
+}
+
+impl Template {
+    pub const ALL: [Template; 4] = [Self::Command, Self::Theme, Self::IconTheme, Self::Language];
+
+    pub fn parse(s: &str) -> Result<Self, String> {
+        Self::ALL
+            .into_iter()
+            .find(|t| t.label() == s)
+            .ok_or_else(|| format!("unknown template {s:?} (command, theme, icon-theme, language)"))
+    }
+
+    pub fn label(self) -> &'static str {
+        match self {
+            Self::Command => "command",
+            Self::Theme => "theme",
+            Self::IconTheme => "icon-theme",
+            Self::Language => "language",
+        }
+    }
+}
+
+pub struct Vars<'a> {
+    pub id: &'a str,
+    pub name: &'a str,
+    /// The SDK dependency, as a TOML value (`{ path = "…" }`).
+    pub sdk: Option<&'a str>,
+}
+
+/// `(relative path, contents)` of every file of the template.
+pub fn render(template: Template, vars: &Vars) -> Vec<(String, String)> {
+    let slug = vars.id.rsplit('.').next().unwrap_or(vars.id).to_owned();
+    let crate_name = format!("openidea-plugin-{}", vars.id.replace('.', "-"));
+    let fill = |s: &str| {
+        s.replace("__ID__", vars.id)
+            .replace("__SLUG__", &slug)
+            .replace("__NAME__", vars.name)
+            .replace("__CRATE__", &crate_name)
+            .replace("__SDK__", vars.sdk.unwrap_or(""))
+            // The theme files come from the Harbor Night plugin.
+            .replace("harbor-night", &slug)
+            .replace("Harbor Night", vars.name)
+    };
+    let files: Vec<(String, &str)> = match template {
+        Template::Command => vec![
+            ("plugin.toml".into(), COMMAND_MANIFEST),
+            ("Cargo.toml".into(), COMMAND_CARGO),
+            ("src/lib.rs".into(), COMMAND_LIB),
+            (".gitignore".into(), "/target\n"),
+            ("README.md".into(), COMMAND_README),
+        ],
+        Template::Theme => vec![
+            ("plugin.toml".into(), THEME_MANIFEST),
+            (format!("themes/{slug}.theme.json"), THEME_UI),
+            (format!("themes/{slug}.scheme.json"), THEME_SCHEME),
+        ],
+        Template::IconTheme => vec![
+            ("plugin.toml".into(), ICON_MANIFEST),
+            ("icons/theme.json".into(), ICON_THEME),
+            ("icons/file.svg".into(), ICON_FILE),
+            ("icons/folder.svg".into(), ICON_FOLDER),
+            ("icons/folder-open.svg".into(), ICON_FOLDER_OPEN),
+            ("icons/markdown.svg".into(), ICON_MARKDOWN),
+        ],
+        Template::Language => {
+            vec![("plugin.toml".into(), LANGUAGE_MANIFEST), (format!("languages/{slug}.toml"), LANGUAGE_DEF)]
+        }
+    };
+    files.into_iter().map(|(path, content)| (path, fill(content))).collect()
+}
+
+const COMMAND_MANIFEST: &str = r#"id = "__ID__"
+name = "__NAME__"
+version = "0.1.0"
+description = "Adds two sample commands."
+authors = []
+# Marketplace categories (up to 3): languages, themes, icon-themes, linters,
+# vcs, ai, frameworks, tools, other.
+categories = ["tools"]
+engines.openidea = "^1.0"
+# Built by `openidea-plugin build`. The code is loaded the first time one of
+# its commands runs; the commands below show in Find Action before that.
+wasm = "dist/plugin.wasm"
+
+# What the code may do. The user approves these when installing.
+[capabilities]
+required = ["editor.read"]
+
+[[contributes.commands]]
+id = "say-hello"
+title = "__NAME__: Say Hello"
+category = "__NAME__"
+
+[[contributes.commands]]
+id = "line-count"
+title = "__NAME__: Line Count of Active File"
+category = "__NAME__"
+"#;
+
+const COMMAND_CARGO: &str = r#"[package]
+name = "__CRATE__"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+# A plugin builds on its own (target wasm32-wasip2), outside any IDE workspace.
+[workspace]
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+openidea-plugin = __SDK__
+
+[profile.release]
+opt-level = "s"
+lto = true
+strip = true
+codegen-units = 1
+panic = "abort"
+"#;
+
+const COMMAND_LIB: &str = r#"//! __NAME__: an OpenIDEA plugin.
+
+use openidea_plugin::{Error, Invocation, NotificationLevel, Plugin, host, register_plugin};
+
+#[derive(Default)]
+pub struct Main {
+    greetings: u32,
+}
+
+impl Plugin for Main {
+    fn run_command(&mut self, id: &str, ctx: &Invocation, _arg: Option<&str>) -> Result<Option<String>, Error> {
+        match id {
+            "say-hello" => {
+                // Instance state lasts until the plugin is idle for a while;
+                // keep what must survive in `host::storage`.
+                self.greetings += 1;
+                let body = format!("Hello #{} from __NAME__!", self.greetings);
+                host::notify(NotificationLevel::Info, "__NAME__", &body);
+                Ok(None)
+            }
+            "line-count" => {
+                let editor = ctx.editor().ok_or("no file is open")?;
+                let text = editor.document()?.text;
+                Ok(Some(format!("{} lines in {}", text.lines().count(), editor.path())))
+            }
+            _ => Err(format!("unknown command {id}").into()),
+        }
+    }
+}
+
+register_plugin!(Main);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use openidea_plugin::mock::MockHost;
+
+    #[test]
+    fn says_hello() {
+        let host = MockHost::install();
+        let mut plugin = Main::default();
+        plugin.run_command("say-hello", &host.invocation(), None).unwrap();
+        plugin.run_command("say-hello", &host.invocation(), None).unwrap();
+        assert_eq!(host.notifications()[1].body, "Hello #2 from __NAME__!");
+    }
+
+    #[test]
+    fn counts_lines() {
+        let host = MockHost::install();
+        host.open_editor("/project/src/main.rs", "rust", "fn main() {\n}\n", &[]);
+        let out = Main::default().run_command("line-count", &host.invocation(), None).unwrap();
+        assert_eq!(out.as_deref(), Some("2 lines in /project/src/main.rs"));
+    }
+}
+"#;
+
+const COMMAND_README: &str = r#"# __NAME__
+
+An OpenIDEA plugin.
+
+```sh
+cargo test                       # logic, against the SDK's mock host
+openidea-plugin build            # → dist/plugin.wasm, validated like an install
+openidea-plugin link             # load this folder in the IDE (Settings › Plugins)
+```
+
+`plugin.toml` declares the commands, so they appear in Find Action before the
+code is loaded, and the capabilities the code needs. `src/lib.rs` implements
+them with the `openidea-plugin` SDK.
+"#;
+
+const THEME_MANIFEST: &str = r#"id = "__ID__"
+name = "__NAME__"
+version = "0.1.0"
+description = "A dark theme."
+authors = []
+engines.openidea = "^1.0"
+
+# One entry per theme. `editor-scheme` is optional: its tokens are merged over
+# the theme's (IntelliJ's .theme.json + .icls pair). Reference: docs/plugins/themes.md.
+[[contributes.themes]]
+path = "themes/__SLUG__.theme.json"
+editor-scheme = "themes/__SLUG__.scheme.json"
+"#;
+
+const THEME_UI: &str = include_str!("../../../../../plugins/official/harbor-night/themes/harbor-night.theme.json");
+const THEME_SCHEME: &str = include_str!("../../../../../plugins/official/harbor-night/themes/harbor-night.scheme.json");
+
+const ICON_MANIFEST: &str = r#"id = "__ID__"
+name = "__NAME__"
+version = "0.1.0"
+description = "File and folder icons."
+authors = []
+engines.openidea = "^1.0"
+
+# Apply it in Settings › Plugins › __NAME__. SVGs are sanitised on install:
+# no scripts, event handlers, external references or entities.
+[[contributes.iconThemes]]
+id = "__SLUG__"
+label = "__NAME__"
+path = "icons/theme.json"
+"#;
+
+const ICON_THEME: &str = r#"{
+  "iconDefinitions": {
+    "file": "icons/file.svg",
+    "folder": "icons/folder.svg",
+    "folder-open": "icons/folder-open.svg",
+    "markdown": "icons/markdown.svg"
+  },
+  "file": "file",
+  "folder": "folder",
+  "folderExpanded": "folder-open",
+  "fileExtensions": { "md": "markdown", "markdown": "markdown" },
+  "fileNames": { "readme": "markdown" },
+  "folderNames": {}
+}
+"#;
+
+const ICON_FILE: &str = r##"<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><path fill="#90a4ae" d="M4 1.5h5.5L13 5v9.5H4z"/><path fill="#cfd8dc" d="M9.5 1.5V5H13z"/></svg>
+"##;
+
+const ICON_FOLDER: &str = r##"<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><path fill="#90a4ae" d="M1.5 3h5l1.5 1.5h6.5v9h-13z"/></svg>
+"##;
+
+const ICON_FOLDER_OPEN: &str = r##"<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><path fill="#90a4ae" d="M1.5 3h5l1.5 1.5h6v2h-10l-2 7h-.5z"/><path fill="#b0bec5" d="M4 7.5h11.5l-2 6H2z"/></svg>
+"##;
+
+const ICON_MARKDOWN: &str = r##"<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><rect x="1" y="3.5" width="14" height="9" rx="1.5" fill="#42a5f5"/><path fill="#fff" d="M3 10.5v-5h1.5L6 7.5l1.5-2H9v5H7.5V8L6 10 4.5 8v2.5zm8 0L9.5 8h1V5.5H12V8h1z"/></svg>
+"##;
+
+const LANGUAGE_MANIFEST: &str = r#"id = "__ID__"
+name = "__NAME__"
+version = "0.1.0"
+description = "Language support for .__SLUG__ files: detection, comments and indentation."
+authors = []
+engines.openidea = "^1.0"
+
+# Same format as languages/<id>.toml in the IDE repository.
+[[contributes.languages]]
+path = "languages/__SLUG__.toml"
+"#;
+
+const LANGUAGE_DEF: &str = r##"id = "__SLUG__"
+name = "__NAME__"
+extensions = ["__SLUG__"]
+line-comment = "#"
+indent = { tab-size = 2, insert-spaces = true }
+# Borrow an existing CodeMirror mode for instant highlighting.
+ui-mode = "Properties files"
+"##;

crates/ide-host/src/bin/server.rs

@@ -1,6 +1,8 @@
 //! `openidea-server --stdio`: the IDE backend for remote development, serving
 //! one desktop client over stdin / stdout (started by the client over SSH).
 
+use ide_host::plugins::remote::{RemotePluginLanguages, SYNC_COMMAND};
+use ide_host::plugins::remote_host::RemotePlugins;
 use ide_host::rpc::{self, Dispatcher};
 use ide_host::{Host, HostConfig};
 use ide_language::LanguageRegistry;
@@ -51,8 +53,12 @@ async fn run(base: PathBuf) -> i32 {
             return 1;
         }
     };
+    // The desktop's plugin languages (`plugin_sync_languages`); programs pinned on this machine.
+    let plugin_languages = RemotePluginLanguages::new(Some(&data_dir));
+    languages.attach_plugins(plugin_languages.store().clone());
     let peer = Arc::new(OnceLock::new());
     let sink_peer = peer.clone();
+    let plugins_data = data_dir.clone();
     let host = Arc::new(Host::new(HostConfig {
         config_dir,
         local_data_dir: data_dir.clone(),
@@ -64,8 +70,31 @@ async fn run(base: PathBuf) -> i32 {
         runtime: tokio::runtime::Handle::current(),
         project_environment: true,
     }));
+    // The desktop's code plugins run here, next to the project (`plugin_sync_packages`).
+    let plugins = match RemotePlugins::start(&plugins_data, &host, peer.clone()) {
+        Ok(p) => Some(p),
+        Err(e) => {
+            tracing::warn!("plugins are unavailable: {e}");
+            None
+        }
+    };
     tracing::info!("openidea-server {} ready", env!("CARGO_PKG_VERSION"));
-    rpc::serve(host.clone(), Dispatcher::standard(), peer, tokio::io::stdin(), tokio::io::stdout()).await;
+    let mut dispatcher = Dispatcher::standard();
+    if let Some(plugins) = &plugins {
+        plugins.register(&mut dispatcher);
+    }
+    dispatcher.add(SYNC_COMMAND, move |c| {
+        let remote = plugin_languages.clone();
+        async move {
+            let report = remote.sync(c.arg("languages")?);
+            c.host.plugin_languages_changed();
+            Ok(report)
+        }
+    });
+    rpc::serve(host.clone(), dispatcher, peer, tokio::io::stdin(), tokio::io::stdout()).await;
+    if let Some(plugins) = &plugins {
+        plugins.host().shutdown();
+    }
     // `process::exit` skips destructors: nothing started for the client may outlive it.
     if tokio::time::timeout(std::time::Duration::from_secs(10), host.shutdown()).await.is_err() {
         tracing::warn!("language servers did not shut down in time");

crates/ide-host/src/formatter.rs

@@ -2,26 +2,48 @@
 
 use crate::Host;
 use ide_core::event::NotifyLevel;
-use ide_core::settings::PrettierSettings;
+use ide_core::settings::{ExternalFormatter, LanguagesSettings};
 use ide_core::{DocId, IdeError, IdeEvent, IdeResult, Range, TextEdit};
-use ide_language::FormatterConfig;
+use ide_language::LanguageConfig;
 use ide_lsp::types::FormatOptions;
 use ide_tools::{Tools, formatter};
 use std::path::Path;
 
 const OXFMT_CONFIGS: [&str; 4] = [".oxfmtrc.json", ".oxfmtrc.jsonc", "oxfmt.config.ts", "oxfmt.config.mts"];
 
-/// oxfmt below an oxfmt configuration file, else Prettier. The Prettier
-/// settings (languages, preference, on save) apply to both.
-fn external_tool(file: &Path) -> &'static str {
-    let oxfmt = OXFMT_CONFIGS.iter().any(|name| formatter::find_up(file, Path::new(name)).is_some());
-    if oxfmt { "oxfmt" } else { "prettier" }
-}
-
-fn external_selected(config: Option<&FormatterConfig>, language: &str, settings: &PrettierSettings, lsp: bool) -> bool {
-    config.is_some_and(|c| c.tool == "prettier")
-        && settings.languages.iter().any(|l| l == language)
-        && (settings.prefer || !lsp)
+/// The external formatter of a file, for a language with an external formatter.
+/// `forced` names the tool (Reformat with Prettier/oxfmt). Otherwise oxfmt
+/// applies when it is enabled for the language and either an oxfmt
+/// configuration is found above the file or oxfmt is the selected provider;
+/// else Prettier, when it is enabled. Turning Prettier off for a language
+/// leaves it to the language server, not to oxfmt.
+fn external_tool(
+    forced: Option<ExternalFormatter>,
+    language: Option<&LanguageConfig>,
+    file: &Path,
+    settings: &LanguagesSettings,
+) -> IdeResult<Option<ExternalFormatter>> {
+    use ExternalFormatter::{Oxfmt, Prettier};
+    let Some(language) = language.filter(|l| l.formatter.as_ref().is_some_and(|f| f.tool == "prettier")) else {
+        return match forced {
+            Some(tool) => Err(IdeError::invalid(format!(
+                "{} cannot format {} files",
+                formatter::display_name(tool.name()),
+                language.map_or("these", |l| l.name.as_str())
+            ))),
+            None => Ok(None),
+        };
+    };
+    if forced.is_some() {
+        return Ok(forced);
+    }
+    let enabled = |tool| settings.formatter(tool).languages.iter().any(|l| l == language.id.as_str());
+    let oxfmt_config = || OXFMT_CONFIGS.iter().any(|name| formatter::find_up(file, Path::new(name)).is_some());
+    Ok(if enabled(Oxfmt) && (settings.oxfmt.prefer || oxfmt_config()) {
+        Some(Oxfmt)
+    } else {
+        enabled(Prettier).then_some(Prettier)
+    })
 }
 
 pub async fn format(
@@ -34,29 +56,33 @@ pub async fn format(
     let project = host.project(window)?;
     let snap = project.documents.snapshot(doc)?;
     let settings = project.settings.effective();
-    let prettier = &settings.languages.prettier;
     let language = project.languages.get(&snap.language);
-    let config = language.as_ref().and_then(|l| l.formatter.as_ref());
-    let candidate =
-        config.is_some_and(|c| c.tool == "prettier") && prettier.languages.iter().any(|l| l == snap.language.as_str());
-    let lsp = if candidate && !prettier.prefer { project.lsp.can_format(doc).await? } else { false };
-    if !external_selected(config, snap.language.as_str(), prettier, lsp) {
+    let mut selected = external_tool(options.tool, language.as_ref(), &snap.path, &settings.languages)?;
+    if let Some(tool) = selected
+        && options.tool.is_none()
+        && !settings.languages.formatter(tool).prefer
+        && project.lsp.can_format(doc).await?
+    {
+        selected = None;
+    }
+    let Some(selected) = selected else {
         if options.on_save && !settings.editor.format_on_save {
             return Ok(Vec::new());
         }
         return project.lsp.format(doc, range, options).await;
-    }
-    if options.on_save && !prettier.run_on_save {
+    };
+    let tool_settings = settings.languages.formatter(selected);
+    if options.on_save && !tool_settings.run_on_save {
         return Ok(Vec::new());
     }
     host.require_trust(window)?;
     if snap.read_only {
         return Err(IdeError::invalid("The file is read-only"));
     }
-    let config = config.unwrap().clone();
-    let tool = external_tool(&snap.path);
+    let config = language.and_then(|l| l.formatter).expect("external_tool selects languages with a formatter");
+    let tool = selected.name();
     let name = formatter::display_name(tool);
-    let custom = ide_sdk::apply::setting_path(&project.root, &prettier.path).filter(|_| tool == "prettier");
+    let custom = ide_sdk::apply::setting_path(&project.root, &tool_settings.path);
     let tools = Tools::new(&host.local_data_dir);
     let whole_selection = range.is_some() && !formatter::supports_range(tool, &config);
     let edits: IdeResult<Vec<TextEdit>> = tokio::task::spawn_blocking(move || {
@@ -94,42 +120,76 @@ pub async fn format(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use ExternalFormatter::{Oxfmt, Prettier};
+    use ide_core::LanguageId;
+    use ide_language::LanguageRegistry;
 
-    #[test]
-    fn language_enablement_and_preference_preserve_lsp_formatters() {
-        let languages = ide_language::LanguageRegistry::load(None).unwrap();
-        let mut settings = PrettierSettings::default();
-        for lang in languages.all() {
-            for lsp in [false, true] {
-                let configured = lang.formatter.as_ref().is_some_and(|f| f.tool == "prettier");
-                assert_eq!(
-                    external_selected(lang.formatter.as_ref(), lang.id.as_str(), &settings, lsp),
-                    configured && !lsp,
-                    "{}",
-                    lang.id
-                );
-            }
-        }
-        let ts = languages.get(&ide_core::LanguageId::new("typescript")).unwrap();
-        settings.prefer = true;
-        assert!(external_selected(ts.formatter.as_ref(), "typescript", &settings, true));
-        settings.languages.clear();
-        assert!(!external_selected(ts.formatter.as_ref(), "typescript", &settings, false));
-        assert!(!external_selected(None, "rust", &settings, false));
+    fn tool(
+        forced: Option<ExternalFormatter>,
+        language: &str,
+        file: &Path,
+        settings: &LanguagesSettings,
+    ) -> IdeResult<Option<ExternalFormatter>> {
+        let language = LanguageRegistry::load(None).unwrap().get(&LanguageId::new(language));
+        external_tool(forced, language.as_ref(), file, settings)
     }
 
     #[test]
-    fn oxfmt_config_selects_oxfmt_over_prettier() {
+    fn default_settings_give_every_external_formatter_language_to_prettier() {
+        let settings = LanguagesSettings::default();
+        let file = Path::new("/project/file");
+        for lang in LanguageRegistry::load(None).unwrap().all() {
+            let configured = lang.formatter.as_ref().is_some_and(|f| f.tool == "prettier");
+            let selected = external_tool(None, Some(&lang), file, &settings).unwrap();
+            assert_eq!(selected, configured.then_some(Prettier), "{}", lang.id);
+        }
+        assert_eq!(external_tool(None, None, file, &settings).unwrap(), None);
+    }
+
+    #[test]
+    fn oxfmt_config_selects_oxfmt_for_its_enabled_languages() {
         let dir = tempfile::tempdir().unwrap();
         let root = dir.path();
         std::fs::create_dir_all(root.join("web/src")).unwrap();
         let (web, api) = (root.join("web/src/app.ts"), root.join("api/main.ts"));
-        assert_eq!(external_tool(&web), "prettier");
+        let mut settings = LanguagesSettings::default();
+        assert_eq!(tool(None, "typescript", &web, &settings).unwrap(), Some(Prettier));
         for config in OXFMT_CONFIGS {
             std::fs::write(root.join("web").join(config), "{}").unwrap();
-            assert_eq!(external_tool(&web), "oxfmt", "{config}");
-            assert_eq!(external_tool(&api), "prettier", "{config}");
+            assert_eq!(tool(None, "typescript", &web, &settings).unwrap(), Some(Oxfmt), "{config}");
+            assert_eq!(tool(None, "typescript", &api, &settings).unwrap(), Some(Prettier), "{config}");
             std::fs::remove_file(root.join("web").join(config)).unwrap();
         }
+        std::fs::write(root.join("web/.oxfmtrc.json"), "{}").unwrap();
+        settings.oxfmt.languages.retain(|l| l != "markdown");
+        assert_eq!(tool(None, "markdown", &web, &settings).unwrap(), Some(Prettier));
+        assert_eq!(tool(None, "typescript", &web, &settings).unwrap(), Some(Oxfmt));
+    }
+
+    #[test]
+    fn oxfmt_provider_selects_oxfmt_without_a_config_and_prettier_off_leaves_the_language_server() {
+        let file = Path::new("/project/src/app.ts");
+        let mut settings = LanguagesSettings::default();
+        settings.oxfmt.prefer = true;
+        assert_eq!(tool(None, "typescript", file, &settings).unwrap(), Some(Oxfmt));
+        settings.oxfmt.prefer = false;
+        settings.prettier.languages.clear();
+        assert_eq!(tool(None, "typescript", file, &settings).unwrap(), None);
+        settings.oxfmt.prefer = true;
+        settings.oxfmt.languages.clear();
+        assert_eq!(tool(None, "typescript", file, &settings).unwrap(), None);
+    }
+
+    #[test]
+    fn forced_tool_runs_that_formatter_or_reports_why_not() {
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::write(dir.path().join(".oxfmtrc.json"), "{}").unwrap();
+        let file = dir.path().join("app.ts");
+        let mut settings = LanguagesSettings::default();
+        settings.oxfmt.languages.clear();
+        assert_eq!(tool(Some(Prettier), "typescript", &file, &settings).unwrap(), Some(Prettier));
+        assert_eq!(tool(Some(Oxfmt), "typescript", &file, &settings).unwrap(), Some(Oxfmt));
+        let rust = tool(Some(Oxfmt), "rust", &dir.path().join("main.rs"), &settings).unwrap_err();
+        assert_eq!(rust.message, "oxfmt cannot format Rust files");
     }
 }

crates/ide-host/src/lib.rs

@@ -1,6 +1,6 @@
 //! The IDE backend without a UI toolkit: open projects per window, terminals,
 //! processes, settings and the remote services. The desktop shell (`src-tauri`)
-//! wraps one [`Host`] and adds windows, menus and plugins; `openidea-server`
+//! wraps one [`Host`] and adds windows and menus; `openidea-server`
 //! runs one on a remote machine and serves it over JSON-RPC ([`rpc`]).
 
 pub mod data_dirs;
@@ -10,6 +10,7 @@ mod java_runtime;
 mod kotlin_bridge;
 pub mod notebook;
 pub mod ops;
+pub mod plugins;
 mod project;
 mod proxy;
 mod requests;
@@ -78,6 +79,7 @@ pub struct Host {
     pub runtime: tokio::runtime::Handle,
     /// One project per window, keyed by window label.
     projects: RwLock<HashMap<String, Arc<Project>>>,
+    pub(crate) external_logs: RwLock<HashMap<String, Vec<Arc<ide_vcs::Repo>>>>,
     requests: requests::Requests,
     project_requests: RwLock<HashMap<String, Vec<RequestId>>>,
 }
@@ -121,6 +123,7 @@ impl Host {
             owner,
             runtime,
             projects: RwLock::default(),
+            external_logs: RwLock::default(),
             requests: Default::default(),
             project_requests: RwLock::default(),
         };
@@ -133,6 +136,17 @@ impl Host {
         self.syntax.get_or_init(|| Arc::new(Syntax::new())).clone()
     }
 
+    /// Plugin languages or the servers they may start changed (they are part
+    /// of [`Self::languages`] and every project's fork): open documents are
+    /// detected again and language servers follow their new configuration.
+    pub fn plugin_languages_changed(&self) {
+        for project in self.projects() {
+            project.documents.redetect_languages();
+            let lsp = project.lsp.clone();
+            self.runtime.spawn(async move { lsp.reconfigure().await });
+        }
+    }
+
     /// Every open project (all windows).
     pub fn projects(&self) -> Vec<Arc<Project>> {
         self.projects.read().values().cloned().collect()
@@ -166,6 +180,10 @@ impl Host {
     }
 
     pub fn close_project(&self, window: &str) {
+        self.external_logs.write().remove(self.owner_window(window));
+        for request in self.project_requests.write().remove(self.owner_window(window)).unwrap_or_default() {
+            self.cancel_request(request);
+        }
         let project = self.projects.write().remove(window);
         if let Some(project) = project {
             if !project.light {
@@ -181,9 +199,6 @@ impl Host {
             // asked for, its runs, its shells and its debug sessions — and the language
             // servers finish shutting down before the window is gone, as IDEA closes a
             // project's processes.
-            for request in self.project_requests.write().remove(self.owner_window(window)).unwrap_or_default() {
-                self.cancel_request(request);
-            }
             self.processes.kill_project(&project.root);
             self.terminals.kill_key(self.owner_window(window));
             self.shutdown_project_workers_blocking(
@@ -299,14 +314,20 @@ impl Host {
     }
 
     pub fn begin_project_request(&self, window: &str, id: RequestId) -> CancellationToken {
-        let token = self.begin_request(id);
-        self.project_requests.write().entry(self.owner_window(window).to_owned()).or_default().push(id);
+        let token = self.begin_project_read_request(window, id);
         if self.project(window).is_ok_and(|p| !p.is_trusted()) {
             token.cancel();
         }
         token
     }
 
+    /// Read-only work remains cancellable/disposed with its window in restricted projects.
+    pub fn begin_project_read_request(&self, window: &str, id: RequestId) -> CancellationToken {
+        let token = self.begin_request(id);
+        self.project_requests.write().entry(self.owner_window(window).to_owned()).or_default().push(id);
+        token
+    }
+
     pub fn end_request(&self, id: RequestId) {
         for ids in self.project_requests.write().values_mut() {
             ids.retain(|entry| *entry != id);

crates/ide-host/src/ops/agent.rs

@@ -30,6 +30,17 @@ pub fn set_command(host: &Host, window: &str, id: String, command: Option<String
     host.project(window)?.agents.set_builtin_command(&id, command)
 }
 
+/// Environment variables built-in agent `id` starts with; empty clears them.
+pub fn set_env(
+    host: &Host,
+    window: &str,
+    id: String,
+    env: std::collections::BTreeMap<String, String>,
+) -> IdeResult<()> {
+    host.require_trust(window)?;
+    host.project(window)?.agents.set_builtin_env(&id, env)
+}
+
 /// Where ACP Registry agents are saved (`<config>/agents`, like the user's own) and installed.
 pub(crate) fn registry_paths(host: &Host) -> RegistryPaths {
     RegistryPaths::new(&host.config_dir, &host.local_data_dir)
@@ -195,6 +206,7 @@ pub(crate) fn register(d: &mut Dispatcher) {
     d.add("agent_subscribe", |c| async move { subscribe(&c.host, &c.window, c.channel("onEvent")?) });
     d.add("agent_providers", |c| async move { providers(&c.host, &c.window) });
     d.add("agent_set_command", |c| async move { set_command(&c.host, &c.window, c.arg("id")?, c.arg("command")?) });
+    d.add("agent_set_env", |c| async move { set_env(&c.host, &c.window, c.arg("id")?, c.arg("env")?) });
     d.add("agent_registry_list", |c| async move { registry_list(&c.host, &c.window, c.arg("request")?).await });
     d.add("agent_registry_install", |c| async move {
         registry_install(&c.host, &c.window, c.arg("id")?, c.arg("request")?, c.sender("onEvent")?).await

crates/ide-host/src/ops/build.rs

@@ -116,6 +116,11 @@ pub async fn build_sync(
             tracing::warn!("Maven profiles not saved: {e}");
             false
         });
+    if profiles_changed {
+        // The modules of the chosen profiles are read from the POMs with them from now on (the
+        // project tree's module folders too), whether or not Maven itself can run.
+        project.sink.emit(ide_core::IdeEvent::ProjectRootsChanged { root: project.root.clone().into() });
+    }
     let token = host.begin_project_request(window, request);
     let result = tokio::task::spawn_blocking(move || {
         let current = load(&root, &cache, &settings);
@@ -150,6 +155,13 @@ pub async fn build_sync(
     .map_err(join_err);
     host.end_request(request);
     let model = result??;
+    if tool == BuildTool::Gradle {
+        // The sync may report project folders outside the project (`includeFlat`): index and list them.
+        project.refresh_index_scope();
+        project.sink.emit(ide_core::IdeEvent::ProjectRootsChanged { root: project.root.clone().into() });
+        let p = project.clone();
+        tokio::task::spawn_blocking(move || p.refresh_repositories());
+    }
     if tool == BuildTool::Maven
         && model.maven.is_some()
         && let Some(bridge) = &project.kotlin_bridge
@@ -168,7 +180,16 @@ pub async fn build_sync(
         }
     };
     let lsp = project.lsp.clone();
-    let uris = build_files.iter().map(|f| ide_lsp::path_to_uri_string(&project.root.join(f))).collect();
+    // With a module of a reactor unlinked, jdtls imports the other modules one by one and
+    // not the reactor: naming the reactor here would import it again, all modules included.
+    let imported = match tool {
+        BuildTool::Maven => crate::project::jdtls_maven_import(&project.root, &project.settings.effective()).1,
+        BuildTool::Gradle => None,
+    };
+    let uris = match imported {
+        Some(files) => files.into_iter().filter(|f| f.ends_with("/pom.xml")).collect(),
+        None => build_files.iter().map(|f| ide_lsp::path_to_uri_string(&project.root.join(f))).collect(),
+    };
     tokio::spawn(async move {
         if profiles_changed {
             // jdtls takes the profiles from its Maven settings (see `ide_sdk::maven_profiles`).
@@ -201,6 +222,52 @@ fn declaring_pom(
     )))
 }
 
+/// The `.toml` of a version catalog the build imports as `group:artifact:version`, once a
+/// build has downloaded it (`ide_sdk::libraries::published_version_catalog`).
+pub async fn gradle_published_catalog(
+    host: &Host,
+    window: &str,
+    coordinates: String,
+) -> IdeResult<Option<ide_core::IpcPath>> {
+    let project = host.project(window)?;
+    tokio::task::spawn_blocking(move || {
+        ide_sdk::libraries::published_version_catalog(&project.root, &project.settings.effective(), &coordinates)
+            .map(Into::into)
+    })
+    .await
+    .map_err(join_err)
+}
+
+/// The resolved dependency tree of the Gradle project `gradle_path` (`:`, `:app`) for
+/// `configuration`, from Gradle's `dependencies` report; cancellable with `cancel_request(request)`.
+pub async fn gradle_dependencies(
+    host: &Host,
+    window: &str,
+    gradle_path: String,
+    configuration: String,
+    offline: bool,
+    request: RequestId,
+) -> 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 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()),
+            ..Default::default()
+        };
+        ide_build::gradle_dependencies(&root, &options, &gradle_path, &configuration, &token)
+    })
+    .await
+    .map_err(join_err);
+    host.end_request(request);
+    result?
+}
+
 /// Where the direct dependency `dependency` of the Maven module `pom` is declared.
 pub async fn maven_dependency_declaration(
     host: &Host,
@@ -280,7 +347,7 @@ pub async fn build_run(
                 let settings = ide_workspace::SettingsStore::load(&config_dir, Some(member)).effective();
                 let member_cache = cache.join(crate::project::project_key(member));
                 let model = with_profiles(load(member, &member_cache, &settings), &member_cache);
-                let plan = compile::plan(member, &model, kind, file.as_deref())?;
+                let plan = compile::plan(member, &model, kind, file.as_deref(), settings.cmake.profiles.as_deref())?;
                 match &mut combined {
                     Some(combined) => combined.steps.extend(plan.steps),
                     None => combined = Some(plan),
@@ -290,7 +357,13 @@ pub async fn build_run(
             plan.title = workspace.name;
             plan
         } else {
-            compile::plan(&root, &with_profiles(load(&root, &cache, &settings), &cache), kind, file.as_deref())?
+            compile::plan(
+                &root,
+                &with_profiles(load(&root, &cache, &settings), &cache),
+                kind,
+                file.as_deref(),
+                settings.cmake.profiles.as_deref(),
+            )?
         };
         let result = compile::run(&root, &plan, &token, &|e| {
             let _ = on_event.send(e);
@@ -321,6 +394,20 @@ pub(crate) fn register(d: &mut Dispatcher) {
         )
         .await
     });
+    d.add("gradle_published_catalog", |c| async move {
+        gradle_published_catalog(&c.host, &c.window, c.arg("coordinates")?).await
+    });
+    d.add("gradle_dependencies", |c| async move {
+        gradle_dependencies(
+            &c.host,
+            &c.window,
+            c.arg("gradlePath")?,
+            c.arg("configuration")?,
+            c.arg("offline")?,
+            c.arg("request")?,
+        )
+        .await
+    });
     d.add("maven_dependency_declaration", |c| async move {
         maven_dependency_declaration(&c.host, &c.window, c.arg("pom")?, c.arg("dependency")?).await
     });

crates/ide-host/src/ops/db.rs

@@ -0,0 +1,421 @@
+//! Database commands shared by the desktop shell's IPC commands and the
+//! remote server ([`crate::rpc`]). `db_export_file` stays in the desktop
+//! shell: its path comes from a local save dialog, so the export must land
+//! on the user's machine, not the side the project runs on.
+use crate::Host;
+use crate::rpc::Dispatcher;
+use ide_core::{IdeError, IdeResult, IpcPath, RequestId};
+use ide_db::split::SqlStatement;
+use ide_db::{
+    CompletionModel, DataSource, Databases, DbObjectKind, DbRowEdit, HistoryEntry, PlanNode, QueryResult,
+    SchemaObjects, SortKey, TableDetails, TableInfo, TablePage,
+};
+use serde::{Deserialize, Serialize};
+use specta::Type;
+
+/// One statement of a console run.
+#[derive(Clone, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+#[serde(rename = "DbStatementOutcome")]
+pub struct StatementOutcome {
+    pub statement: SqlStatement,
+    pub result: Option<QueryResult>,
+    pub error: Option<String>,
+}
+
+pub(crate) fn register(d: &mut Dispatcher) {
+    d.add("db_sources", |c| async move { sources(&c.host, &c.window) });
+    d.add("db_save_sources", |c| async move {
+        let sources = c.arg("sources")?;
+        save_sources(&c.host, &c.window, sources).await
+    });
+    d.add("db_set_password", |c| async move {
+        let (id, password, save) =
+            (c.arg::<String>("id")?, c.arg::<Option<String>>("password")?, c.arg::<bool>("save")?);
+        set_password(&c.host, &c.window, &id, password, save).await
+    });
+    d.add("db_test", |c| async move {
+        let (source, password, ssh_secret) = (
+            c.arg::<DataSource>("source")?,
+            c.arg::<Option<String>>("password")?,
+            c.arg::<Option<String>>("sshSecret")?,
+        );
+        test(&c.host, &c.window, source, password, ssh_secret).await
+    });
+    d.add("db_set_ssh_secret", |c| async move {
+        let (id, secret, save) = (c.arg::<String>("id")?, c.arg::<Option<String>>("secret")?, c.arg::<bool>("save")?);
+        set_ssh_secret(&c.host, &c.window, &id, secret, save).await
+    });
+    d.add("db_trust_ssh_host", |c| async move {
+        let id = c.arg::<String>("id")?;
+        trust_ssh_host(&c.host, &c.window, &id).await
+    });
+    d.add("db_connected", |c| async move { connected(&c.host, &c.window) });
+    d.add("db_connect", |c| async move {
+        let id = c.arg::<String>("id")?;
+        connect(&c.host, &c.window, &id).await
+    });
+    d.add("db_set_manual_commit", |c| async move {
+        let (id, manual) = (c.arg::<String>("id")?, c.arg::<bool>("manual")?);
+        set_manual_commit(&c.host, &c.window, &id, manual).await
+    });
+    d.add("db_finish_transaction", |c| async move {
+        let (id, commit) = (c.arg::<String>("id")?, c.arg::<bool>("commit")?);
+        finish_transaction(&c.host, &c.window, &id, commit).await
+    });
+    d.add("db_disconnect", |c| async move {
+        let id = c.arg::<String>("id")?;
+        disconnect(&c.host, &c.window, &id).await
+    });
+    d.add("db_databases", |c| async move {
+        let id = c.arg::<String>("id")?;
+        databases(&c.host, &c.window, &id).await
+    });
+    d.add("db_schemas", |c| async move {
+        let id = c.arg::<String>("id")?;
+        schemas(&c.host, &c.window, &id).await
+    });
+    d.add("db_tables", |c| async move {
+        let (id, schema) = (c.arg::<String>("id")?, c.arg::<String>("schema")?);
+        tables(&c.host, &c.window, &id, &schema).await
+    });
+    d.add("db_table_details", |c| async move {
+        let (id, schema, table) = (c.arg::<String>("id")?, c.arg::<String>("schema")?, c.arg::<String>("table")?);
+        table_details(&c.host, &c.window, &id, &schema, &table).await
+    });
+    d.add("db_ddl", |c| async move {
+        let (id, schema, table) = (c.arg::<String>("id")?, c.arg::<String>("schema")?, c.arg::<String>("table")?);
+        ddl(&c.host, &c.window, &id, &schema, &table).await
+    });
+    d.add("db_schema_objects", |c| async move {
+        let (id, schema) = (c.arg::<String>("id")?, c.arg::<String>("schema")?);
+        schema_objects(&c.host, &c.window, &id, &schema).await
+    });
+    d.add("db_object_ddl", |c| async move {
+        let (id, schema, kind, name) = (
+            c.arg::<String>("id")?,
+            c.arg::<String>("schema")?,
+            c.arg::<DbObjectKind>("kind")?,
+            c.arg::<String>("name")?,
+        );
+        object_ddl(&c.host, &c.window, &id, &schema, kind, &name).await
+    });
+    d.add("db_explain", |c| async move {
+        let (request, id, statement) =
+            (c.arg::<RequestId>("request")?, c.arg::<String>("id")?, c.arg::<String>("statement")?);
+        explain(&c.host, &c.window, request, &id, &statement).await
+    });
+    d.add("db_history", |c| async move {
+        let id = c.arg::<String>("id")?;
+        history(&c.host, &c.window, &id).await
+    });
+    d.add("db_remove_history", |c| async move {
+        let (id, texts) = (c.arg::<String>("id")?, c.arg::<Option<Vec<String>>>("texts")?);
+        remove_history(&c.host, &c.window, &id, texts).await
+    });
+    d.add("db_completion", |c| async move {
+        let id = c.arg::<String>("id")?;
+        completion(&c.host, &c.window, &id).await
+    });
+    d.add("db_statements", |c| async move {
+        let (id, text, from, to) =
+            (c.arg::<String>("id")?, c.arg::<String>("text")?, c.arg::<u32>("from")?, c.arg::<u32>("to")?);
+        statements(&c.host, &c.window, &id, &text, from, to)
+    });
+    d.add("db_execute", |c| async move {
+        let (request, id, statements, max_rows) = (
+            c.arg::<RequestId>("request")?,
+            c.arg::<String>("id")?,
+            c.arg::<Vec<SqlStatement>>("statements")?,
+            c.arg::<u32>("maxRows")?,
+        );
+        execute(&c.host, &c.window, request, &id, statements, max_rows).await
+    });
+    d.add("db_table_page", |c| async move {
+        let (request, id, schema, table) = (
+            c.arg::<RequestId>("request")?,
+            c.arg::<String>("id")?,
+            c.arg::<String>("schema")?,
+            c.arg::<String>("table")?,
+        );
+        let (filter, sort, offset, limit) = (
+            c.arg::<Option<String>>("filter")?,
+            c.arg::<Vec<SortKey>>("sort")?,
+            c.arg::<u32>("offset")?,
+            c.arg::<u32>("limit")?,
+        );
+        table_page(&c.host, &c.window, request, &id, &schema, &table, filter, sort, offset, limit).await
+    });
+    d.add("db_apply_edits", |c| async move {
+        let (id, schema, table, edits) = (
+            c.arg::<String>("id")?,
+            c.arg::<String>("schema")?,
+            c.arg::<String>("table")?,
+            c.arg::<Vec<DbRowEdit>>("edits")?,
+        );
+        apply_edits(&c.host, &c.window, &id, &schema, &table, edits).await
+    });
+    d.add("db_console_path", |c| async move { console_path(&c.host, &c.arg::<String>("id")?) });
+}
+
+/// The data sources configured for the project (the tree's roots).
+pub fn sources(host: &Host, window: &str) -> IdeResult<Vec<DataSource>> {
+    host.project(window)?.db.sources()
+}
+
+/// Replaces the project's data sources with `sources`.
+pub async fn save_sources(host: &Host, window: &str, sources: Vec<DataSource>) -> IdeResult<()> {
+    let db = host.project(window)?.db.clone();
+    db.save_sources(sources).await
+}
+
+/// Remembers the password of data source `id` for the session, and in the OS
+/// saved passwords when `save` (`None` forgets it).
+pub async fn set_password(host: &Host, window: &str, id: &str, password: Option<String>, save: bool) -> IdeResult<()> {
+    let db = host.project(window)?.db.clone();
+    db.set_password(id, password, save).await
+}
+
+/// Test Connection: connects with unsaved settings and returns the server version.
+pub async fn test(
+    host: &Host,
+    window: &str,
+    source: DataSource,
+    password: Option<String>,
+    ssh_secret: Option<String>,
+) -> IdeResult<String> {
+    let db = host.project(window)?.db.clone();
+    db.test(&source, password, ssh_secret).await
+}
+
+/// Remembers the SSH password / key passphrase of a data source (see `set_password`).
+pub async fn set_ssh_secret(host: &Host, window: &str, id: &str, secret: Option<String>, save: bool) -> IdeResult<()> {
+    let db = host.project(window)?.db.clone();
+    db.set_ssh_secret(id, secret, save).await
+}
+
+/// Trusts the SSH host key that made the last connection of `id` fail with
+/// "Unknown SSH host key" (records it in `~/.ssh/known_hosts`).
+pub async fn trust_ssh_host(host: &Host, window: &str, id: &str) -> IdeResult<()> {
+    let db = host.project(window)?.db.clone();
+    db.trust_ssh_host(id).await
+}
+
+/// The data sources with an open connection.
+pub fn connected(host: &Host, window: &str) -> IdeResult<Vec<String>> {
+    Ok(host.project(window)?.db.connected())
+}
+
+/// Connects (fails with `permissionDenied` when the password is missing or wrong).
+pub async fn connect(host: &Host, window: &str, id: &str) -> IdeResult<()> {
+    let db = host.project(window)?.db.clone();
+    db.pool(id).await.map(|_| ())
+}
+
+/// Switches a data source between auto-commit and manual commit (leaving
+/// manual mode rolls back what was not committed).
+pub async fn set_manual_commit(host: &Host, window: &str, id: &str, manual: bool) -> IdeResult<()> {
+    let db = host.project(window)?.db.clone();
+    db.set_manual_commit(id, manual).await
+}
+
+/// Commits or rolls back the open transaction of a manual-commit data source.
+pub async fn finish_transaction(host: &Host, window: &str, id: &str, commit: bool) -> IdeResult<()> {
+    let db = host.project(window)?.db.clone();
+    db.finish_transaction(id, commit).await
+}
+
+/// Closes the connection of data source `id`.
+pub async fn disconnect(host: &Host, window: &str, id: &str) -> IdeResult<()> {
+    let db = host.project(window)?.db.clone();
+    db.disconnect(id).await;
+    Ok(())
+}
+
+/// Databases of the server of data source `id` (PostgreSQL); connect to one as `<id>:<database>`.
+pub async fn databases(host: &Host, window: &str, id: &str) -> IdeResult<Databases> {
+    let db = host.project(window)?.db.clone();
+    db.databases(id).await
+}
+
+/// The schemas of data source `id`.
+pub async fn schemas(host: &Host, window: &str, id: &str) -> IdeResult<Vec<String>> {
+    let db = host.project(window)?.db.clone();
+    db.schemas(id).await
+}
+
+/// The tables and views of `schema`.
+pub async fn tables(host: &Host, window: &str, id: &str, schema: &str) -> IdeResult<Vec<TableInfo>> {
+    let db = host.project(window)?.db.clone();
+    db.tables(id, schema).await
+}
+
+/// Columns, keys and indexes of `table`.
+pub async fn table_details(host: &Host, window: &str, id: &str, schema: &str, table: &str) -> IdeResult<TableDetails> {
+    let db = host.project(window)?.db.clone();
+    db.table_details(id, schema, table).await
+}
+
+/// The DDL of table or view `table` (Go to DDL, Generate DDL).
+pub async fn ddl(host: &Host, window: &str, id: &str, schema: &str, table: &str) -> IdeResult<String> {
+    let db = host.project(window)?.db.clone();
+    db.ddl(id, schema, table).await
+}
+
+/// The routines and sequences of `schema` (the tree's `routines` / `sequences`).
+pub async fn schema_objects(host: &Host, window: &str, id: &str, schema: &str) -> IdeResult<SchemaObjects> {
+    let db = host.project(window)?.db.clone();
+    db.schema_objects(id, schema).await
+}
+
+/// The definition of a routine, trigger or sequence (Go to DDL, Quick Documentation).
+pub async fn object_ddl(
+    host: &Host,
+    window: &str,
+    id: &str,
+    schema: &str,
+    kind: DbObjectKind,
+    name: &str,
+) -> IdeResult<String> {
+    let db = host.project(window)?.db.clone();
+    db.object_ddl(id, schema, kind, name).await
+}
+
+/// Explain Plan: the execution plan of `statement` on `id`, without running it.
+pub async fn explain(
+    host: &Host,
+    window: &str,
+    request: RequestId,
+    id: &str,
+    statement: &str,
+) -> IdeResult<Vec<PlanNode>> {
+    let db = host.project(window)?.db.clone();
+    let cancel = host.begin_request(request);
+    let result = db.explain(id, statement, &cancel).await;
+    host.end_request(request);
+    result
+}
+
+/// The statements data source `id` ran, newest first (Browse Query History).
+pub async fn history(host: &Host, window: &str, id: &str) -> IdeResult<Vec<HistoryEntry>> {
+    let db = host.project(window)?.db.clone();
+    db.history(id).await
+}
+
+/// Removes statements from the query history of `id` (`None`: all of them).
+pub async fn remove_history(host: &Host, window: &str, id: &str, texts: Option<Vec<String>>) -> IdeResult<()> {
+    let db = host.project(window)?.db.clone();
+    db.remove_history(id, texts).await
+}
+
+/// Tables, columns and foreign keys for SQL completion.
+pub async fn completion(host: &Host, window: &str, id: &str) -> IdeResult<CompletionModel> {
+    let db = host.project(window)?.db.clone();
+    db.completion(id).await
+}
+
+/// Statements a console runs: the selection's (`from < to`) or the one at the caret (`from`).
+pub fn statements(host: &Host, window: &str, id: &str, text: &str, from: u32, to: u32) -> IdeResult<Vec<SqlStatement>> {
+    let driver = host.project(window)?.db.source(id)?.driver;
+    Ok(if from < to {
+        ide_db::split::statements_in(text, from, to, driver)
+    } else {
+        ide_db::split::statement_at(text, from, driver).into_iter().collect()
+    })
+}
+
+/// Runs `statements` in order on data source `id`, stopping at the first
+/// error. Cancel with `cancel_request(request)`.
+pub async fn execute(
+    host: &Host,
+    window: &str,
+    request: RequestId,
+    id: &str,
+    statements: Vec<SqlStatement>,
+    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 {
+            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);
+                return Err(e);
+            }
+            Err(e) if e.kind == ide_core::error::ErrorKind::PermissionDenied && out.is_empty() => {
+                // Not connected for lack of a password: the UI asks and retries.
+                host.end_request(request);
+                return Err(e);
+            }
+            Err(e) => {
+                out.push(StatementOutcome { statement, result: None, error: Some(e.message) });
+                break;
+            }
+        }
+    }
+    host.end_request(request);
+    Ok(out)
+}
+
+/// One page of the rows of `table` (the table editor).
+#[allow(clippy::too_many_arguments)]
+pub async fn table_page(
+    host: &Host,
+    window: &str,
+    request: RequestId,
+    id: &str,
+    schema: &str,
+    table: &str,
+    filter: Option<String>,
+    sort: Vec<SortKey>,
+    offset: u32,
+    limit: u32,
+) -> IdeResult<TablePage> {
+    let db = host.project(window)?.db.clone();
+    let cancel = host.begin_request(request);
+    let result =
+        db.table_page(id, schema, table, filter.as_deref(), &sort, offset.into(), limit.max(1).into(), &cancel).await;
+    host.end_request(request);
+    result
+}
+
+/// Submits the table editor's changes in one transaction; returns the rows changed.
+pub async fn apply_edits(
+    host: &Host,
+    window: &str,
+    id: &str,
+    schema: &str,
+    table: &str,
+    edits: Vec<DbRowEdit>,
+) -> IdeResult<f64> {
+    let db = host.project(window)?.db.clone();
+    Ok(db.apply_edits(id, schema, table, &edits).await? as f64)
+}
+
+/// The query console file of data source `id` (`<dataDir>/consoles/db/<id>/console.sql`),
+/// created on first use. Consoles are files of the project, so a remote
+/// window resolves it on the host the project runs on.
+pub fn console_path(host: &Host, id: &str) -> IdeResult<IpcPath> {
+    let (source, database) = ide_db::split_target(id);
+    if source.is_empty() || !source.chars().all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_') {
+        return Err(IdeError::invalid("invalid data source id"));
+    }
+    // One console per database: `<id>` for the default one, `<id>.<database>` for the others.
+    let name = match database {
+        Some(db) => {
+            let safe: String =
+                db.chars().map(|c| if c.is_alphanumeric() || c == '-' || c == '_' { c } else { '_' }).collect();
+            format!("{source}.{safe}")
+        }
+        None => source.to_owned(),
+    };
+    let dir = host.data_dir.join("consoles").join("db").join(&name);
+    std::fs::create_dir_all(&dir)?;
+    let file = dir.join("console.sql");
+    if !file.exists() {
+        std::fs::write(&file, "")?;
+    }
+    Ok(file.into())
+}

crates/ide-host/src/ops/debug.rs

@@ -188,6 +188,19 @@ pub async fn debug_stop(host: &Host, _window: &str, session: DebugSessionId) ->
     host.debugger.stop(session).await
 }
 
+/// The adapter's completions for an expression being typed in the frame `frame_id`.
+pub async fn debug_completions(
+    host: &Host,
+    _window: &str,
+    session: DebugSessionId,
+    frame_id: Option<i64>,
+    text: String,
+    line: u32,
+    column: u32,
+) -> IdeResult<Vec<ide_dap::DebugCompletion>> {
+    host.debugger.completions(session, frame_id, text, line, column).await
+}
+
 /// Evaluate with an explicit DAP context: `repl`, `watch`, `hover` or `clipboard`.
 pub async fn debug_evaluate_in(
     host: &Host,
@@ -376,6 +389,18 @@ pub(crate) fn register(d: &mut Dispatcher) {
         .await
     });
     d.add("debug_stop", |c| async move { debug_stop(&c.host, &c.window, c.arg("session")?).await });
+    d.add("debug_completions", |c| async move {
+        debug_completions(
+            &c.host,
+            &c.window,
+            c.arg("session")?,
+            c.arg("frameId")?,
+            c.arg("text")?,
+            c.arg("line")?,
+            c.arg("column")?,
+        )
+        .await
+    });
     d.add("debug_evaluate_in", |c| async move {
         debug_evaluate_in(
             &c.host,

crates/ide-host/src/ops/doc/commands.rs

@@ -18,7 +18,7 @@ pub async fn blocking<T: Send + 'static>(f: impl FnOnce() -> IdeResult<T> + Send
 /// editor buffer, so syntax features and language-server requests work in it.
 pub async fn doc_open_virtual(host: &Host, window: &str, uri: String) -> IdeResult<DocumentInfo> {
     let project = host.project(window)?;
-    let vd = project.lsp.virtual_document(&uri).await?;
+    let vd = crate::ops::lsp::lsp_virtual_document(host, window, uri).await?;
     blocking(move || project.documents.open_virtual(&vd.uri, vd.language_id, &vd.text)).await
 }
 

crates/ide-host/src/ops/docker.rs

@@ -0,0 +1,17 @@
+//! Docker run configurations: the environment their `docker` command line runs with.
+use crate::Host;
+use crate::rpc::Dispatcher;
+use ide_core::IdeResult;
+use ide_docker::DockerEndpoint;
+use std::collections::BTreeMap;
+
+/// The endpoint's variables plus a `PATH` that finds this host's `docker`. A remote project
+/// gets them from the server, since its run configurations start on the remote host.
+pub async fn run_env(host: &Host, endpoint: DockerEndpoint) -> IdeResult<BTreeMap<String, String>> {
+    endpoint.validate()?;
+    host.blocking(move || Ok(ide_docker::run_env(&endpoint))).await
+}
+
+pub(crate) fn register(d: &mut Dispatcher) {
+    d.add("docker_run_env", |c| async move { run_env(&c.host, c.arg("endpoint")?).await });
+}

crates/ide-host/src/ops/fs.rs

@@ -137,16 +137,23 @@ pub fn set_writable(host: &Host, window: &str, path: PathBuf, writable: bool) ->
 pub async fn delete(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
     let history = host.project(window).ok().map(|p| p.history.clone());
     host.blocking(move || {
+        let paths = ide_workspace::file_ops::deletion_paths(&path)?;
         if let Some(h) = history {
-            h.record_deletion(&path, DELETE_SNAPSHOT_LIMIT);
+            for p in paths {
+                h.record_deletion(&p, DELETE_SNAPSHOT_LIMIT);
+            }
         }
-        ide_vfs::delete(&path)
+        ide_workspace::file_ops::delete(&path)
     })
     .await
 }
 
 pub async fn copy(host: &Host, from: PathBuf, to: PathBuf) -> IdeResult<()> {
-    host.blocking(move || ide_vfs::copy(&from, &to)).await
+    host.blocking(move || ide_workspace::file_ops::copy(&from, &to)).await
+}
+
+pub async fn rename(host: &Host, from: PathBuf, to: PathBuf) -> IdeResult<()> {
+    host.blocking(move || ide_workspace::file_ops::rename(&from, &to)).await
 }
 
 /// Reads a text file without opening it as a document; prefers the unsaved buffer.

crates/ide-host/src/ops/java.rs

@@ -96,7 +96,13 @@ async fn resolve_launch(
         let project_jdk = ide_sdk::apply::project_jdk(&project.root, &settings);
         let from_jdtls = info.java_home.as_deref().map(ide_sdk::java::java_executable).filter(|p| p.is_file());
         let java = project_jdk.map(|j| ide_sdk::java::java_executable(&j.home)).or(from_jdtls).or_else(|| {
-            let release = ide_sdk::java::project_java_version(&module);
+            // The build model's level includes what the module inherits from its parent POMs.
+            let release = model
+                .maven
+                .as_ref()
+                .and_then(|m| m.projects.iter().find(|p| project.root.join(&p.dir) == module))
+                .and_then(|p| p.java_version)
+                .or_else(|| ide_sdk::java::project_java_version(&module));
             let jdks = ide_sdk::java::installed_jdks();
             info.hints.extend(ide_sdk::java::missing_jdk_message(&jdks, release));
             ide_sdk::java::pick_jdk(&jdks, release).map(|j| ide_sdk::java::java_executable(&j.home))

crates/ide-host/src/ops/jvm_icons.rs

@@ -1,7 +1,7 @@
 //! Bounded, read-only JVM presentation for visible files, also served remotely.
 use crate::Host;
 use ide_core::{CancellationToken, IdeError, IdeResult, LanguageId};
-use ide_syntax::{JvmPresentation, Snapshot};
+use ide_syntax::{JvmPresentation, Snapshot, StructureService, jvm_type_header};
 use serde::{Deserialize, Serialize};
 use specta::Type;
 use std::{
@@ -38,6 +38,27 @@ fn prefix(path: &PathBuf) -> std::io::Result<String> {
     Ok(String::from_utf8_lossy(&bytes).into_owned())
 }
 
+/// The presentation of the file at `path` from its first [`PREFIX_BYTES`].
+fn read_presentation(
+    structure: &StructureService,
+    path: &PathBuf,
+    language: &LanguageId,
+) -> IdeResult<JvmPresentation> {
+    let source = prefix(path)?;
+    let stem = path.file_stem().and_then(|s| s.to_str()).unwrap_or_default();
+    let present =
+        |source: &str| structure.jvm_presentation(&Snapshot::text(language, source), stem, &CancellationToken::new());
+    let presentation = present(&source)?;
+    // Cut off inside its body, a large file doesn't parse as a declaration: its header does.
+    if presentation.kind.is_none()
+        && source.len() as u64 >= PREFIX_BYTES
+        && let Some(header) = jvm_type_header(&source)
+    {
+        return Ok(present(&format!("{header}}}"))?);
+    }
+    Ok(presentation)
+}
+
 pub async fn jvm_file_presentations(
     host: &Host,
     window: &str,
@@ -67,13 +88,7 @@ pub async fn jvm_file_presentations(
             let presentation = if let Some(hit) = hit {
                 hit.presentation
             } else {
-                let Ok(source) = prefix(&path) else { continue };
-                let stem = path.file_stem().and_then(|s| s.to_str()).unwrap_or_default();
-                let presentation = project.structure.jvm_presentation(
-                    &Snapshot::text(&language, &source),
-                    stem,
-                    &CancellationToken::new(),
-                )?;
+                let Ok(presentation) = read_presentation(&project.structure, &path, &language) else { continue };
                 let mut cache = cache.lock().unwrap();
                 if cache.len() >= MAX_CACHE {
                     cache.clear();
@@ -99,4 +114,21 @@ mod tests {
         assert_eq!(prefix(&path).unwrap().len(), PREFIX_BYTES as usize);
         std::fs::remove_file(path).unwrap();
     }
+
+    #[test]
+    fn large_files_cut_off_in_their_body_keep_their_kind() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("Foo.java");
+        let mut text = String::from("package a;\n\n@Service\npublic class Foo implements IFoo {\n");
+        while text.len() < PREFIX_BYTES as usize + 1024 {
+            // The prefix ends inside one of these comments.
+            text.push_str("    /**\n     * Does something.\n     */\n    public void m() { call(\"x\"); }\n");
+        }
+        std::fs::write(&path, &text).unwrap();
+        let syntax = std::sync::Arc::new(ide_language::Syntax::new());
+        let structure = StructureService::new(std::sync::Arc::new(ide_language::SyntaxCache::new(syntax)));
+        let java = LanguageId::new("java");
+        let presentation = read_presentation(&structure, &path, &java).unwrap();
+        assert_eq!(presentation.kind, Some(ide_syntax::JvmTypeKind::Class));
+    }
 }

crates/ide-host/src/ops/lsp.rs

@@ -1,9 +1,11 @@
 use super::doc::blocking;
 use crate::Host;
 use crate::apply_workspace_edit as apply_edit;
+use crate::plugins::{ProviderKind, editor_providers_for as editor_providers};
 use crate::rpc::Dispatcher;
 use ide_core::{DocId, IdeResult, Location, Pos, Range, RequestId, ServerId, TextEdit, WorkspaceEdit};
 use ide_lsp::types::*;
+use ide_plugin::ProviderDocument;
 
 async fn prepare_actions(
     project: std::sync::Arc<crate::Project>,
@@ -38,9 +40,107 @@ pub async fn lsp_completion(
 ) -> IdeResult<CompletionList> {
     let lsp = host.project(window)?.lsp.clone();
     let cancel = host.begin_request(request);
-    let result = lsp.completion(doc, pos, trigger, cancel).await;
+    let result = lsp.completion(doc, pos, trigger.clone(), cancel).await;
     host.end_request(request);
-    result
+    // Plugin providers (`[[contributes.providers]]`) add theirs.
+    let Some((plugins, d)) = plugin_providers(host, window, doc, ProviderKind::Completion) else { return result };
+    let items = plugin_call(move || plugins.provide_completion(&d, pos, trigger.as_deref())).await.unwrap_or_default();
+    if items.is_empty() {
+        return result;
+    }
+    let mut list = result.unwrap_or(CompletionList { is_incomplete: false, items: Vec::new() });
+    list.items.extend(items.into_iter().map(|(_, item)| plugin_completion(item)));
+    Ok(list)
+}
+
+/// The plugin host and the document, when some plugin provides `kind`.
+fn plugin_providers(
+    host: &Host,
+    window: &str,
+    doc: DocId,
+    kind: ProviderKind,
+) -> Option<(std::sync::Arc<crate::plugins::PluginHost>, ProviderDocument)> {
+    let plugins = editor_providers(kind)?;
+    let snap = host.project(window).ok()?.documents.snapshot(doc).ok()?;
+    let d = ProviderDocument {
+        path: snap.path.0,
+        language: snap.language.0,
+        version: u64::from(snap.version),
+        text: snap.text,
+    };
+    Some((plugins, d))
+}
+
+/// Plugin calls block (the plugin's actor thread does the work).
+async fn plugin_call<T: Send + 'static>(f: impl FnOnce() -> T + Send + 'static) -> Option<T> {
+    tokio::task::spawn_blocking(f).await.ok()
+}
+
+/// Items from plugins carry no server: commands don't apply, and a code
+/// action is resolved by the plugin named in its `data` ([`PluginActionRef`]).
+const PLUGIN_SERVER: ServerId = ServerId(0);
+
+/// `data` of a plugin's code action whose edits it computes when picked.
+#[derive(serde::Serialize, serde::Deserialize)]
+struct PluginActionRef {
+    plugin: String,
+    data: String,
+}
+
+/// A plugin's `completion-item.kind` (wit/providers.wit lists them).
+fn plugin_completion_kind(kind: &str) -> Option<CompletionKind> {
+    Some(match kind {
+        "text" => CompletionKind::Text,
+        "method" => CompletionKind::Method,
+        "function" => CompletionKind::Function,
+        "constructor" => CompletionKind::Constructor,
+        "field" => CompletionKind::Field,
+        "variable" => CompletionKind::Variable,
+        "class" => CompletionKind::Class,
+        "interface" => CompletionKind::Interface,
+        "module" => CompletionKind::Module,
+        "property" => CompletionKind::Property,
+        "unit" => CompletionKind::Unit,
+        "value" => CompletionKind::Value,
+        "enum" => CompletionKind::Enum,
+        "keyword" => CompletionKind::Keyword,
+        "snippet" => CompletionKind::Snippet,
+        "color" => CompletionKind::Color,
+        "file" => CompletionKind::File,
+        "reference" => CompletionKind::Reference,
+        "folder" => CompletionKind::Folder,
+        "enum-member" => CompletionKind::EnumMember,
+        "constant" => CompletionKind::Constant,
+        "struct" => CompletionKind::Struct,
+        "event" => CompletionKind::Event,
+        "operator" => CompletionKind::Operator,
+        "type-parameter" => CompletionKind::TypeParameter,
+        _ => return None,
+    })
+}
+
+fn plugin_completion(item: ide_plugin::CompletionItem) -> CompletionItem {
+    let kind = item.kind.as_deref().and_then(plugin_completion_kind);
+    CompletionItem {
+        label: item.label,
+        label_detail: None,
+        detail: item.detail,
+        kind,
+        documentation: item.documentation.map(|value| Markup { kind: "markdown".into(), value }),
+        sort_text: item.sort_text,
+        filter_text: item.filter_text,
+        preselect: false,
+        deprecated: false,
+        insert_text: item.insert_text,
+        is_snippet: item.snippet,
+        replace_range: item.replace,
+        replace_range_tab: None,
+        additional_edits: item.additional_edits,
+        commit_characters: Vec::new(),
+        command: None,
+        data: None,
+        server: PLUGIN_SERVER,
+    }
 }
 
 /// Inline (ghost text) suggestions at `pos`; `automatic` when triggered by typing.
@@ -54,9 +154,26 @@ pub async fn lsp_inline_completion(
 ) -> IdeResult<Vec<InlineCompletionItem>> {
     let lsp = host.project(window)?.lsp.clone();
     let cancel = host.begin_request(request);
-    let result = lsp.inline_completion(doc, pos, automatic, cancel).await;
+    let result = lsp.inline_completion(doc, pos, automatic, cancel.clone()).await;
+    // Plugins: cancelled (cooperatively) when the editor cancels the request.
+    let plugin = match plugin_providers(host, window, doc, ProviderKind::InlineCompletion) {
+        Some((plugins, d)) if !matches!(&result, Ok(items) if !items.is_empty()) => {
+            let cancel = cancel.clone();
+            plugin_call(move || plugins.provide_inline_completion(&d, pos, &cancel)).await.flatten()
+        }
+        _ => None,
+    };
     host.end_request(request);
-    result
+    match plugin {
+        Some((_, s)) => Ok(vec![InlineCompletionItem {
+            insert_text: s.insert_text,
+            range: s.replace,
+            filter_text: None,
+            command: None,
+            server: PLUGIN_SERVER,
+        }]),
+        None => result,
+    }
 }
 
 pub async fn lsp_resolve_completion(
@@ -87,7 +204,40 @@ pub async fn lsp_signature_help(host: &Host, window: &str, doc: DocId, pos: Pos)
 }
 
 pub async fn lsp_goto(host: &Host, window: &str, doc: DocId, pos: Pos, kind: GotoKind) -> IdeResult<Vec<Location>> {
-    host.project(window)?.lsp.goto(doc, pos, kind).await
+    let result = host.project(window)?.lsp.goto(doc, pos, kind).await;
+    if kind != GotoKind::Definition {
+        return result;
+    }
+    let Some((plugins, d)) = plugin_providers(host, window, doc, ProviderKind::Definition) else { return result };
+    let found = plugin_call(move || plugins.provide_definition(&d, pos)).await.unwrap_or_default();
+    if found.is_empty() {
+        return result;
+    }
+    let mut out = result.unwrap_or_default();
+    out.extend(found.into_iter().map(|l| Location { path: l.path.into(), range: l.range, uri: None }));
+    Ok(out)
+}
+
+/// Gutter markers from plugins (`line-markers` providers) for `doc`.
+pub async fn plugin_line_markers(
+    host: &Host,
+    window: &str,
+    doc: DocId,
+) -> IdeResult<Vec<crate::plugins::LineMarkerInfo>> {
+    let Some((plugins, d)) = plugin_providers(host, window, doc, ProviderKind::LineMarkers) else {
+        return Ok(Vec::new());
+    };
+    let markers = plugin_call(move || plugins.provide_line_markers(&d)).await.unwrap_or_default();
+    Ok(markers
+        .into_iter()
+        .map(|(plugin_id, m)| crate::plugins::LineMarkerInfo {
+            plugin_id,
+            line: m.line,
+            icon: m.icon,
+            tooltip: m.tooltip,
+            target: m.target.map(|l| Location { path: l.path.into(), range: l.range, uri: None }),
+        })
+        .collect())
 }
 
 /// Implementations of the symbols at `positions`, one list per position (the
@@ -110,6 +260,9 @@ pub async fn lsp_implementations(
 /// Contents of a read-only language-server document, including JDT library
 /// classes and disk class files. Cached per project.
 pub async fn lsp_virtual_document(host: &Host, window: &str, uri: String) -> IdeResult<VirtualDocument> {
+    if uri.starts_with("git-revision:") {
+        return crate::ops::vcs::revision_virtual_document(host, window, &uri).await;
+    }
     host.project(window)?.lsp.virtual_document(&uri).await
 }
 
@@ -165,10 +318,76 @@ pub async fn lsp_code_actions(
     let project = host.project(window)?;
     let documents = project.documents.clone();
     let version = blocking(move || documents.version(doc)).await?;
-    let actions = project.lsp.code_actions(doc, range, only).await?;
+    let result = project.lsp.code_actions(doc, range, only.clone()).await;
+    let plugin_actions = match plugin_providers(host, window, doc, ProviderKind::CodeActions) {
+        Some((plugins, d)) => plugin_call(move || plugins.provide_code_actions(&d, range)).await.unwrap_or_default(),
+        None => Vec::new(),
+    };
+    let plugin_actions: Vec<CodeAction> = plugin_actions
+        .into_iter()
+        .map(|(plugin, a)| plugin_code_action(&plugin, a))
+        .filter(|a| {
+            only.is_empty()
+                || a.kind.as_ref().is_some_and(|k| only.iter().any(|o| k == o || k.starts_with(&format!("{o}."))))
+        })
+        .collect();
+    let actions = if plugin_actions.is_empty() {
+        result?
+    } else {
+        let mut out = result.unwrap_or_default();
+        out.extend(plugin_actions);
+        out
+    };
     prepare_actions(project, doc, version, actions).await
 }
 
+fn plugin_code_action(plugin: &str, a: ide_plugin::CodeAction) -> CodeAction {
+    // With `data` and no edits, the plugin computes them when the action is picked.
+    let lazy = a.edits.is_empty() && a.data.is_some();
+    let files: Vec<_> = a
+        .edits
+        .into_iter()
+        .map(|(path, edits)| ide_core::FileEdit::Edit { path: path.into(), edits, version: None })
+        .collect();
+    let data = a
+        .data
+        .filter(|_| lazy)
+        .and_then(|data| serde_json::to_value(PluginActionRef { plugin: plugin.to_owned(), data }).ok());
+    CodeAction {
+        title: a.title,
+        kind: a.kind,
+        is_preferred: a.preferred,
+        disabled_reason: None,
+        edit: (!lazy).then(|| WorkspaceEdit { files, preconditions: Vec::new() }),
+        command: None,
+        data,
+        server: PLUGIN_SERVER,
+    }
+}
+
+/// A code action resolved by whoever offered it: its language server, or
+/// the plugin its `data` names.
+async fn resolve_action(host: &Host, window: &str, doc: DocId, action: CodeAction) -> IdeResult<CodeAction> {
+    if action.server != PLUGIN_SERVER {
+        return host.project(window)?.lsp.resolve_code_action(doc, action).await;
+    }
+    let Some(r) = action.data.clone().and_then(|d| serde_json::from_value::<PluginActionRef>(d).ok()) else {
+        return Ok(action);
+    };
+    let (plugins, d) = plugin_providers(host, window, doc, ProviderKind::CodeActions)
+        .ok_or_else(|| ide_core::IdeError::unavailable("the plugin that offered this action is gone"))?;
+    let pending = ide_plugin::CodeAction {
+        title: action.title.clone(),
+        kind: action.kind.clone(),
+        preferred: action.is_preferred,
+        edits: Vec::new(),
+        data: Some(r.data),
+    };
+    let plugin = r.plugin.clone();
+    let resolved = blocking(move || plugins.resolve_code_action(&plugin, &d, pending)).await?;
+    Ok(plugin_code_action(&r.plugin, ide_plugin::CodeAction { data: None, ..resolved }))
+}
+
 /// Cancellable code actions with the kinds the servers advertise (Refactor This, refactoring availability).
 pub async fn lsp_code_action_query(
     host: &Host,
@@ -202,7 +421,7 @@ pub async fn lsp_resolve_code_action(
     let project = host.project(window)?;
     let documents = project.documents.clone();
     let version = blocking(move || documents.version(doc)).await?;
-    let action = project.lsp.resolve_code_action(doc, action).await?;
+    let action = resolve_action(host, window, doc, action).await?;
     Ok(prepare_actions(project, doc, version, vec![action]).await?.remove(0))
 }
 
@@ -212,7 +431,7 @@ pub async fn lsp_apply_code_action(host: &Host, window: &str, doc: DocId, action
     let action = if action.edit.is_none() && action.command.is_none() {
         let documents = project.documents.clone();
         let version = blocking(move || documents.version(doc)).await?;
-        let action = project.lsp.resolve_code_action(doc, action).await?;
+        let action = resolve_action(host, window, doc, action).await?;
         prepare_actions(project.clone(), doc, version, vec![action]).await?.remove(0)
     } else {
         action
@@ -222,17 +441,85 @@ pub async fn lsp_apply_code_action(host: &Host, window: &str, doc: DocId, action
         let edit = edit.clone();
         blocking(move || apply_edit(&documents, &edit)).await?;
     }
-    if let Some(command) = action.command {
+    if let Some(command) = action.command
+        && !(action.edit.is_some() && is_client_follow_up(&project, doc, None, &command).await)
+    {
         project.lsp.execute_command(doc, command).await?;
     }
     Ok(())
 }
 
+/// A command after a code action's edit that no server provides: what other editors'
+/// extensions do once the edit is applied (vtsls' `_typescript.didOrganizeImports`). The edit
+/// is the action; there is nothing to run.
+async fn is_client_follow_up(
+    project: &crate::project::Project,
+    doc: DocId,
+    server: Option<ide_core::ServerId>,
+    command: &Command,
+) -> bool {
+    let provided = project.lsp.provides_command(doc, server, &command.command).await;
+    if !provided {
+        tracing::debug!("skipping `{}` after the code action's edit: no server provides it", command.command);
+    }
+    !provided
+}
+
 pub async fn lsp_prepare_rename(host: &Host, window: &str, doc: DocId, pos: Pos) -> IdeResult<Option<Range>> {
     host.project(window)?.lsp.prepare_rename(doc, pos).await
 }
 
 /// Computes the rename edit without applying it, so the UI can preview conflicts.
+/// The class at `pos` and the members a class-hierarchy refactoring can move.
+pub async fn lsp_hierarchy_members(
+    host: &Host,
+    window: &str,
+    request: RequestId,
+    doc: DocId,
+    pos: Pos,
+    kind: HierarchyRefactoring,
+) -> IdeResult<HierarchyMembers> {
+    let project = host.project(window)?;
+    let cancel = host.begin_request(request);
+    let result = project.lsp.hierarchy_members(doc, pos, kind, cancel).await;
+    host.end_request(request);
+    result
+}
+
+/// Checks a class-hierarchy refactoring and computes its edit without applying it.
+#[allow(clippy::too_many_arguments)]
+pub async fn lsp_hierarchy_refactor(
+    host: &Host,
+    window: &str,
+    request: RequestId,
+    doc: DocId,
+    pos: Pos,
+    kind: HierarchyRefactoring,
+    target: Option<String>,
+    choices: Vec<HierarchyChoice>,
+) -> IdeResult<HierarchyRefactored> {
+    let project = host.project(window)?;
+    let documents = project.documents.clone();
+    let version = blocking(move || documents.version(doc)).await?;
+    let cancel = host.begin_request(request);
+    let result = project.lsp.hierarchy_refactor(doc, pos, kind, target, choices, cancel).await;
+    host.end_request(request);
+    let mut refactored = result?;
+    blocking(move || {
+        if project.documents.version(doc)? != version {
+            return Err(ide_core::IdeError::new(
+                ide_core::error::ErrorKind::OutOfSync,
+                "document changed while computing the refactoring; request it again",
+            ));
+        }
+        if let Some(edit) = &mut refactored.edit {
+            project.documents.prepare_workspace_edit(edit)?;
+        }
+        Ok(refactored)
+    })
+    .await
+}
+
 pub async fn lsp_rename(
     host: &Host,
     window: &str,
@@ -410,6 +697,7 @@ pub async fn lsp_execute_code_action(
         if cancel.is_cancelled() {
             return Err(ide_core::IdeError::cancelled());
         }
+        let edited = action.edit.is_some();
         if let Some(edit) = action.edit {
             let documents = project.documents.clone();
             tokio::task::spawn_blocking(move || apply_edit(&documents, &edit))
@@ -417,6 +705,9 @@ pub async fn lsp_execute_code_action(
                 .map_err(|e| ide_core::IdeError::internal(e.to_string()))??;
         }
         match action.command {
+            Some(command) if edited && is_client_follow_up(&project, doc, Some(action.server), &command).await => {
+                Ok(Vec::new())
+            }
             Some(command) => project
                 .lsp
                 .execute_action_command(doc, action.server, command, answers, cancel)
@@ -497,6 +788,22 @@ pub(crate) fn register(d: &mut Dispatcher) {
     d.add("lsp_rename", |c| async move {
         lsp_rename(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("pos")?, c.arg("newName")?).await
     });
+    d.add("lsp_hierarchy_members", |c| async move {
+        lsp_hierarchy_members(&c.host, &c.window, c.arg("request")?, c.arg("doc")?, c.arg("pos")?, c.arg("kind")?).await
+    });
+    d.add("lsp_hierarchy_refactor", |c| async move {
+        lsp_hierarchy_refactor(
+            &c.host,
+            &c.window,
+            c.arg("request")?,
+            c.arg("doc")?,
+            c.arg("pos")?,
+            c.arg("kind")?,
+            c.arg("target")?,
+            c.arg("choices")?,
+        )
+        .await
+    });
     d.add("lsp_format", |c| async move {
         lsp_format(&c.host, &c.window, c.arg("doc")?, c.arg("range")?, c.arg("options")?).await
     });
@@ -551,3 +858,47 @@ pub(crate) fn register(d: &mut Dispatcher) {
         lsp_execute_command(&c.host, &c.window, c.arg("doc")?, c.arg("command")?).await
     });
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_plugin_action_with_data_and_no_edits_is_resolved_by_its_plugin() {
+        let action = |edits: Vec<(std::path::PathBuf, Vec<TextEdit>)>, data: Option<&str>| ide_plugin::CodeAction {
+            title: "Fix".into(),
+            kind: None,
+            preferred: false,
+            edits,
+            data: data.map(str::to_owned),
+        };
+        let lazy = plugin_code_action("acme.x", action(Vec::new(), Some("ref")));
+        assert!(lazy.edit.is_none());
+        let r: PluginActionRef = serde_json::from_value(lazy.data.unwrap()).unwrap();
+        assert_eq!((r.plugin.as_str(), r.data.as_str()), ("acme.x", "ref"));
+        // With edits, `data` is the plugin's business: applied as is.
+        let edit = TextEdit { range: Range::default(), new_text: "x".into() };
+        let eager = plugin_code_action("acme.x", action(vec![("/a".into(), vec![edit])], Some("ref")));
+        assert!(eager.edit.is_some() && eager.data.is_none());
+    }
+
+    #[test]
+    fn every_completion_kind_the_plugin_api_documents_is_understood() {
+        let wit = include_str!("../../../../wit/providers.wit");
+        let doc: String = wit
+            .lines()
+            .map(|l| l.trim().trim_start_matches("///").trim())
+            .skip_while(|l| !l.starts_with("Icon and sort group:"))
+            .take_while(|l| !l.starts_with("kind:"))
+            .collect::<Vec<_>>()
+            .join(" ");
+        let list = doc.strip_prefix("Icon and sort group:").unwrap().split(". Unknown").next().unwrap();
+        let list = list.replace(" or ", ", ");
+        let kinds: Vec<&str> = list.split(',').map(str::trim).filter(|k| !k.is_empty()).collect();
+        assert_eq!(kinds.len(), 25, "{kinds:?}");
+        for k in kinds {
+            assert!(plugin_completion_kind(k).is_some(), "{k:?}");
+        }
+        assert_eq!(plugin_completion_kind("nonsense"), None);
+    }
+}

crates/ide-host/src/ops/mod.rs

@@ -7,10 +7,12 @@ pub mod analysis;
 pub mod build;
 pub mod bytes;
 pub mod coverage;
+pub mod db;
 pub mod debug;
 pub mod dependencies;
 pub mod deploy;
 pub mod doc;
+pub mod docker;
 pub mod env;
 pub mod fs;
 pub mod history;
@@ -86,6 +88,8 @@ pub fn register_all(d: &mut crate::rpc::Dispatcher) {
     run::register(d);
     env::register(d);
     deploy::register(d);
+    docker::register(d);
+    db::register(d);
 }
 
 impl Host {

crates/ide-host/src/ops/nav.rs

@@ -3,7 +3,7 @@ use crate::Host;
 use crate::Project;
 use crate::rpc::Dispatcher;
 use ide_core::{DocId, IdeResult, IpcPath, Location, Pos};
-use ide_index::{FileMatch, IndexStatus, SymbolFilter, SymbolMatch};
+use ide_index::{ExtensionCount, FileMatch, IndexStatus, SymbolFilter, SymbolMatch};
 use ide_language::{FileReference, WebReference};
 use ide_workspace::file_refs::{self, PathCompletion};
 use serde::{Deserialize, Serialize};
@@ -32,10 +32,19 @@ pub fn index_status(host: &Host, window: &str) -> IdeResult<IndexStatus> {
     Ok(host.project(window)?.index.status())
 }
 
+/// The project's file extensions, most common first.
+pub fn index_file_extensions(host: &Host, window: &str) -> IdeResult<Vec<ExtensionCount>> {
+    Ok(host.project(window)?.index.file_extensions())
+}
+
 pub fn find_files(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
     Ok(host.project(window)?.index.find_files(&query, limit as usize))
 }
 
+pub fn find_dirs(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
+    Ok(host.project(window)?.index.find_dirs(&query, limit as usize))
+}
+
 pub fn find_symbols(
     host: &Host,
     window: &str,
@@ -156,7 +165,9 @@ pub async fn web_unresolved_references(host: &Host, window: &str, doc: DocId) ->
 /// Commands of this module the remote server answers.
 pub(crate) fn register(d: &mut Dispatcher) {
     d.add("index_status", |c| async move { index_status(&c.host, &c.window) });
+    d.add("index_file_extensions", |c| async move { index_file_extensions(&c.host, &c.window) });
     d.add("find_files", |c| async move { find_files(&c.host, &c.window, c.arg("query")?, c.arg("limit")?) });
+    d.add("find_dirs", |c| async move { find_dirs(&c.host, &c.window, c.arg("query")?, c.arg("limit")?) });
     d.add("find_symbols", |c| async move {
         find_symbols(&c.host, &c.window, c.arg("query")?, c.arg("filter")?, c.arg("limit")?)
     });

crates/ide-host/src/ops/project.rs

@@ -17,6 +17,8 @@ pub struct ProjectInfo {
     pub settings: Settings,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub workspace: Option<ide_workspace::workspace::Workspace>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub unity: Option<ide_workspace::unity::UnityProjectInfo>,
 }
 
 pub fn info(project: &Project) -> ProjectInfo {
@@ -33,6 +35,7 @@ pub fn info(project: &Project) -> ProjectInfo {
         settings,
         root: project.root.clone().into(),
         workspace: ide_workspace::workspace::Workspace::load(&project.root).ok().flatten(),
+        unity: ide_workspace::unity::detect(&project.root),
     }
 }
 

crates/ide-host/src/ops/run.rs

@@ -41,7 +41,7 @@ pub fn configs(host: &Host, window: &str) -> IdeResult<Vec<RunConfig>> {
 }
 
 /// A project's detected configurations (minus removed ones and unlinked Maven projects), then
-/// its saved ones; toolchains from Languages & Frameworks applied. Gradle choices stay as saved:
+/// its saved ones; toolchains from Languages & Frameworks applied. Build-tool choices stay as saved:
 /// derived defaults must not be written back as explicit environment.
 fn detected_and_saved(
     root: &std::path::Path,
@@ -56,7 +56,7 @@ fn detected_and_saved(
             .filter(|d| !suppressed.contains(&d.id) && !saved.iter().any(|u| u.id == d.id))
             .collect();
     all.extend(saved.iter().cloned());
-    for config in all.iter_mut().filter(|c| c.kind != "gradle") {
+    for config in all.iter_mut().filter(|c| !matches!(c.kind.as_str(), "gradle" | "maven")) {
         ide_sdk::apply::apply_to_run_configs(std::slice::from_mut(config), root, settings);
     }
     all
@@ -75,13 +75,65 @@ pub fn save_configs(
     let configs: Vec<RunConfig> = configs
         .iter()
         .map(|c| match c.kind.as_str() {
-            "gradle" => c.clone(),
+            "gradle" | "maven" => c.clone(),
             _ => ide_sdk::apply::without_derived(c, &project.root, &settings),
         })
         .collect();
     ide_run::save_user_configs_with_removals(&project.root, &configs, removed_detected_ids)
 }
 
+/// The project `config` runs in (a workspace member, by its working directory) and its settings.
+fn settings_for(
+    host: &Host,
+    project: &crate::project::Project,
+    config: &RunConfig,
+) -> IdeResult<(std::path::PathBuf, ide_core::settings::Settings)> {
+    let member = ide_workspace::workspace::Workspace::load(&project.root)?.and_then(|workspace| {
+        let cwd = config.cwd.as_deref()?;
+        workspace.projects.into_iter().filter(|root| cwd.starts_with(root)).max_by_key(|root| root.components().count())
+    });
+    Ok(match member {
+        Some(root) => {
+            let settings = ide_workspace::SettingsStore::load(&host.config_dir, Some(&root)).effective();
+            (root, settings)
+        }
+        None => (project.root.clone(), project.settings.effective()),
+    })
+}
+
+/// Temporary configurations as they are kept between sessions: without what settings derived
+/// (toolchain commands, Maven options, `JAVA_HOME`…), so they follow later settings changes.
+pub fn without_derived(host: &Host, window: &str, configs: Vec<RunConfig>) -> IdeResult<Vec<RunConfig>> {
+    host.require_trust(window)?;
+    let project = host.project(window)?;
+    configs
+        .into_iter()
+        .map(|c| {
+            if c.kind == "gradle" {
+                return Ok(c);
+            }
+            let (root, settings) = settings_for(host, &project, &c)?;
+            Ok(ide_sdk::apply::without_derived(&c, &root, &settings))
+        })
+        .collect()
+}
+
+/// Kept temporary configurations with today's settings applied, as [`configs`] lists the others.
+pub fn apply_settings(host: &Host, window: &str, configs: Vec<RunConfig>) -> IdeResult<Vec<RunConfig>> {
+    host.require_trust(window)?;
+    let project = host.project(window)?;
+    configs
+        .into_iter()
+        .map(|mut c| {
+            if c.kind != "gradle" {
+                let (root, settings) = settings_for(host, &project, &c)?;
+                ide_sdk::apply::apply_to_run_configs(std::slice::from_mut(&mut c), &root, &settings);
+            }
+            Ok(c)
+        })
+        .collect()
+}
+
 pub async fn start(host: &Host, window: &str, config: RunConfig, on_output: Emit<OutputChunk>) -> IdeResult<RunInfo> {
     host.require_trust(window)?;
     let project = host.project(window)?;
@@ -100,18 +152,16 @@ pub async fn start(host: &Host, window: &str, config: RunConfig, on_output: Emit
             .run(&settings, &project.root, &config, project.sink.clone(), Box::new(move |c| out(c)))
             .await;
     }
-    let member = ide_workspace::workspace::Workspace::load(&project.root)?.and_then(|workspace| {
-        let cwd = config.cwd.as_deref()?;
-        workspace.projects.into_iter().filter(|root| cwd.starts_with(root)).max_by_key(|root| root.components().count())
-    });
-    let root = member.as_ref().unwrap_or(&project.root);
-    let settings = match &member {
-        Some(root) => ide_workspace::SettingsStore::load(&host.config_dir, Some(root)).effective(),
-        None => project.settings.effective(),
-    };
+    let (root, settings) = settings_for(host, &project, &config)?;
+    let root = &root;
     // Configurations made in the UI name bare tools (`godot`) that may live outside PATH.
+    // Maven re-applies too: a config listed before a settings change (daemon toggle,
+    // Maven home) keeps the launcher that was current then; re-resolving at launch is
+    // what makes the setting take effect without reopening the project.
     let mut config = config;
-    if matches!(config.kind.as_str(), "gradle" | "tomcat") {
+    if config.kind == "maven" {
+        ide_sdk::apply::prepare_maven_run(&mut config, root, &settings);
+    } else if matches!(config.kind.as_str(), "gradle" | "tomcat") {
         ide_sdk::apply::apply_to_run_configs(std::slice::from_mut(&mut config), root, &settings);
     } else {
         ide_sdk::apply::resolve_run_command(&mut config, root, &settings);
@@ -147,7 +197,7 @@ pub async fn start(host: &Host, window: &str, config: RunConfig, on_output: Emit
     let encoding = settings.console.encoding;
     let options = StartOptions {
         encoding: Some(encoding).filter(|e| !e.trim().is_empty()),
-        python_paths: if member.is_some() { vec![root.clone()] } else { super::python::paths(&project) },
+        python_paths: if *root != project.root { vec![root.clone()] } else { super::python::paths(&project) },
     };
     project.require_trust()?;
     let mut sink = project.sink.clone();

crates/ide-host/src/ops/run/commands.rs

@@ -4,6 +4,7 @@ use crate::Host;
 use crate::rpc::Dispatcher;
 use ide_core::{IdeError, IdeResult};
 use ide_run::RunConfig;
+use ide_run::import::{RunImport, RunImportSource};
 
 pub async fn run_dotnet_resolve(host: &Host, window: &str, config: RunConfig, debug: bool) -> IdeResult<RunConfig> {
     host.require_trust(window)?;
@@ -105,6 +106,25 @@ pub fn run_save_templates(host: &Host, window: &str, templates: Vec<RunConfig>)
     ide_run::save_templates(&root, &templates)
 }
 
+/// Project files run configurations can be imported from (`.vscode/launch.json`).
+pub fn run_import_sources(host: &Host, window: &str) -> IdeResult<Vec<RunImportSource>> {
+    let root = host.project(window)?.root.clone();
+    Ok(ide_run::import::available(&root))
+}
+
+/// Configurations read from `source`, not saved; names already in `existing` (the
+/// configurations being edited) are skipped.
+pub fn run_import_configs(
+    host: &Host,
+    window: &str,
+    source: RunImportSource,
+    existing: Vec<RunConfig>,
+) -> IdeResult<RunImport> {
+    host.require_trust(window)?;
+    let root = host.project(window)?.root.clone();
+    ide_run::import_configs(&root, source, &existing)
+}
+
 /// The environment runs inherit when "Include system environment variables" is on.
 pub fn run_system_env(_host: &Host, _window: &str) -> std::collections::BTreeMap<String, String> {
     ide_run::system_env()
@@ -122,6 +142,21 @@ pub async fn run_gradle_jvm_args_script(_host: &Host, _window: &str, jvm_args: V
     .map_err(|e| IdeError::internal(e.to_string()))?
 }
 
+/// Writes one of the IDE's Gradle init scripts (`text`; the file is named `<name>-<hash>`) on
+/// the machine that runs the build, for `--init-script`, and returns its path.
+pub async fn run_gradle_init_script(_host: &Host, _window: &str, name: String, text: String) -> IdeResult<String> {
+    if name.is_empty() || !name.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-') {
+        return Err(IdeError::invalid(format!("invalid init script name {name:?}")));
+    }
+    tokio::task::spawn_blocking(move || {
+        ide_run::gradle_jvm::write_script(&ide_run::gradle_jvm::default_dir(), &name, &text)
+            .map(|p| p.to_string_lossy().into_owned())
+            .map_err(|e| IdeError::internal(format!("cannot write the Gradle init script: {e}")))
+    })
+    .await
+    .map_err(|e| IdeError::internal(e.to_string()))?
+}
+
 /// Results from the JUnit XML reports (Surefire, Failsafe, Gradle) of the module at
 /// `module` (relative to the project root) written since `since_ms` (Unix epoch, ms).
 pub async fn run_test_reports(
@@ -221,6 +256,35 @@ pub async fn run_tomcat_update(host: &Host, window: &str, config: RunConfig, mod
         .map_err(|e| IdeError::internal(e.to_string()))?
 }
 
+/// Updates a running Tomcat artifact deployment from the module's compiled output and web
+/// resources (`ide_run::tomcat::sync_outputs`). `false`: rebuild the WAR instead.
+pub async fn run_tomcat_sync(
+    host: &Host,
+    window: &str,
+    config: RunConfig,
+    module: std::path::PathBuf,
+    class_paths: Vec<String>,
+    resources_only: bool,
+) -> IdeResult<bool> {
+    host.require_trust(window)?;
+    let project = host.project(window)?;
+    if !host.processes.list().iter().any(|r| r.running && r.config_id == config.id) {
+        return Err(IdeError::invalid("Start this Tomcat configuration before updating it"));
+    }
+    if config.extras.params.get("deployment").is_some_and(|v| v != "artifact") {
+        return Ok(false);
+    }
+    tokio::task::spawn_blocking(move || {
+        let module = dunce::canonicalize(project.root.join(module))?;
+        let class_paths: Vec<_> =
+            class_paths.iter().filter_map(|p| dunce::canonicalize(project.root.join(p)).ok()).collect();
+        let base = ide_run::tomcat::base_dir(&project.cache_dir, &config.id);
+        ide_run::tomcat::sync_outputs(&base, &module, &class_paths, resources_only)
+    })
+    .await
+    .map_err(|e| IdeError::internal(e.to_string()))?
+}
+
 /// Commands of this module the remote server answers.
 pub(crate) fn register(d: &mut Dispatcher) {
     d.add("run_dotnet_resolve", |c| async move {
@@ -235,15 +299,33 @@ pub(crate) fn register(d: &mut Dispatcher) {
     d.add("run_tomcat_home", |c| async move { run_tomcat_home(&c.host, &c.window, c.arg("home")?).await });
     d.add("run_tomcat_artifacts", |c| async move { run_tomcat_artifacts(&c.host, &c.window).await });
     d.add("run_tomcat_build", |c| async move { run_tomcat_build(&c.host, &c.window, c.arg("config")?).await });
+    d.add("run_tomcat_sync", |c| async move {
+        run_tomcat_sync(
+            &c.host,
+            &c.window,
+            c.arg("config")?,
+            c.arg("module")?,
+            c.arg("classPaths")?,
+            c.arg("resourcesOnly")?,
+        )
+        .await
+    });
     d.add("run_tomcat_update", |c| async move {
         run_tomcat_update(&c.host, &c.window, c.arg("config")?, c.arg("mode")?).await
     });
     d.add("run_templates", |c| async move { run_templates(&c.host, &c.window) });
     d.add("run_save_templates", |c| async move { run_save_templates(&c.host, &c.window, c.arg("templates")?) });
+    d.add("run_import_sources", |c| async move { run_import_sources(&c.host, &c.window) });
+    d.add("run_import_configs", |c| async move {
+        run_import_configs(&c.host, &c.window, c.arg("source")?, c.arg("existing")?)
+    });
     d.add("run_system_env", |c| async move { Ok(run_system_env(&c.host, &c.window)) });
     d.add("run_gradle_jvm_args_script", |c| async move {
         run_gradle_jvm_args_script(&c.host, &c.window, c.arg("jvmArgs")?).await
     });
+    d.add("run_gradle_init_script", |c| async move {
+        run_gradle_init_script(&c.host, &c.window, c.arg("name")?, c.arg("text")?).await
+    });
     d.add("run_test_reports", |c| async move {
         run_test_reports(&c.host, &c.window, c.arg("module")?, c.arg("sinceMs")?).await
     });

crates/ide-host/src/ops/sdk.rs

@@ -34,6 +34,42 @@ pub fn sdk_python_effective(host: &Host, window: &str) -> IdeResult<Option<ide_c
     Ok(ide_sdk::apply::python_interpreter(&project.root, &project.settings.effective()).map(Into::into))
 }
 
+/// The PHP language level of the project `path` belongs to (a workspace member, by path, as
+/// the language server configuration picks it).
+#[derive(Clone, Debug, serde::Serialize, specta::Type)]
+#[serde(rename_all = "camelCase")]
+pub struct PhpLanguageLevels {
+    /// The one Intelephense checks against; `None`: its default.
+    pub effective: Option<ide_sdk::php::PhpLanguageLevel>,
+    /// The one Auto picks, from `composer.json`.
+    pub auto: Option<ide_sdk::php::PhpLanguageLevel>,
+    /// The workspace member `path` belongs to: its own settings choose the level, not the
+    /// workspace's. `None`: the opened project.
+    pub member: Option<ide_core::IpcPath>,
+}
+
+pub async fn sdk_php_language_level(host: &Host, window: &str, path: PathBuf) -> IdeResult<PhpLanguageLevels> {
+    let project = host.project(window)?;
+    let (project_root, project_settings) = (project.root.clone(), project.settings.effective());
+    let config_dir = host.config_dir.clone();
+    tokio::task::spawn_blocking(move || {
+        let member = ide_workspace::workspace::Workspace::load(&project_root).ok().flatten().and_then(|w| {
+            w.projects.into_iter().filter(|p| path.starts_with(p)).max_by_key(|p| p.components().count())
+        });
+        let (root, settings) = match &member {
+            Some(member) => (member, ide_workspace::SettingsStore::load(&config_dir, Some(member)).effective()),
+            None => (&project_root, project_settings),
+        };
+        PhpLanguageLevels {
+            effective: ide_sdk::php::language_level(root, &settings),
+            auto: ide_sdk::php::composer_level(root),
+            member: member.map(ide_core::IpcPath),
+        }
+    })
+    .await
+    .map_err(join_err)
+}
+
 /// SDK / library source folders shown under "External Libraries" in the Project view,
 /// with the Maven / Gradle dependency jars of the build model.
 pub async fn sdk_project_libraries(host: &Host, window: &str) -> IdeResult<Vec<ide_sdk::libraries::LibraryGroup>> {
@@ -144,6 +180,10 @@ pub async fn sdk_python_pip(
 pub(crate) fn register(d: &mut Dispatcher) {
     d.add("sdk_detect", |c| async move { sdk_detect(&c.host, &c.window, c.arg("kind")?).await });
     d.add("sdk_python_effective", |c| async move { sdk_python_effective(&c.host, &c.window) });
+    d.add(
+        "sdk_php_language_level",
+        |c| async move { sdk_php_language_level(&c.host, &c.window, c.arg("path")?).await },
+    );
     d.add("sdk_project_libraries", |c| async move { sdk_project_libraries(&c.host, &c.window).await });
     d.add("sdk_locate_tools", |c| async move {
         sdk_locate_tools(&c.host, &c.window, c.arg("names")?, c.arg("near")?).await

crates/ide-host/src/ops/vcs/commands.rs

@@ -12,6 +12,76 @@ use std::path::{Path, PathBuf};
 
 use crate::apply_git_executable;
 
+/// Read-only repository access also works in a standalone log window.
+struct LogAccess {
+    project: Option<std::sync::Arc<Project>>,
+    external: Option<std::sync::Arc<Repo>>,
+    cache: PathBuf,
+}
+
+/// Immutable Git objects exposed through the editor's ordinary read-only VFS.
+pub async fn revision_virtual_document(
+    host: &Host,
+    window: &str,
+    uri: &str,
+) -> IdeResult<ide_lsp::types::VirtualDocument> {
+    #[derive(Deserialize)]
+    struct Target {
+        repo: PathBuf,
+        revision: String,
+        path: PathBuf,
+    }
+    let encoded = uri
+        .strip_prefix("git-revision:")
+        .and_then(|s| s.split('/').next())
+        .ok_or_else(|| ide_core::IdeError::invalid("invalid Git revision URI"))?;
+    if encoded.len() > 32768 || encoded.len() % 2 != 0 || !encoded.bytes().all(|b| b.is_ascii_hexdigit()) {
+        return Err(ide_core::IdeError::invalid("invalid Git revision URI"));
+    }
+    let bytes = (0..encoded.len())
+        .step_by(2)
+        .map(|i| {
+            u8::from_str_radix(&encoded[i..i + 2], 16)
+                .map_err(|_| ide_core::IdeError::invalid("invalid Git revision URI"))
+        })
+        .collect::<IdeResult<Vec<_>>>()?;
+    let target: Target = serde_json::from_slice(&bytes).map_err(|e| ide_core::IdeError::invalid(e.to_string()))?;
+    let path = target.repo.join(&target.path);
+    let text = vcs_file_at(host, window, path, Some(target.revision.clone()))
+        .await?
+        .ok_or_else(|| ide_core::IdeError::not_found("file is absent at this revision"))?;
+    Ok(ide_lsp::types::VirtualDocument {
+        uri: uri.into(),
+        language_id: host.languages.detect(&target.path, text.lines().next()),
+        text,
+        title: target.path.file_name().unwrap_or_default().to_string_lossy().into_owned(),
+        description: Some(format!("{} · {}", target.repo.display(), target.revision)),
+        decompiled: false,
+    })
+}
+impl LogAccess {
+    fn new(host: &Host, window: &str, at: Option<&Path>) -> Self {
+        let project = host.project(window).ok();
+        let external = host
+            .external_logs
+            .read()
+            .get(host.owner_window(window))
+            .and_then(|rs| rs.iter().find(|r| Some(r.root()) == at).cloned())
+            .filter(|repo| project.as_ref().is_none_or(|p| p.repos().at_root(repo.root()).is_none()));
+        Self { project, external, cache: host.local_data_dir.join("cache/git-log") }
+    }
+    fn with_log_repo_at<T>(&self, at: Option<&Path>, f: impl FnOnce(&Repo) -> IdeResult<T>) -> IdeResult<T> {
+        if let Some(repo) = &self.external {
+            repo.enable_log_index(&self.cache);
+            return f(repo);
+        }
+        self.project
+            .as_ref()
+            .ok_or_else(|| ide_core::IdeError::unavailable("external Git log is not open"))?
+            .with_log_repo_at(at, f)
+    }
+}
+
 /// A repository of the project (IDEA's VCS root).
 #[derive(Serialize, Deserialize, Type)]
 #[serde(rename_all = "camelCase")]
@@ -182,8 +252,8 @@ pub fn vcs_roots(host: &Host, window: &str) -> IdeResult<Vec<VcsRoot>> {
 }
 
 pub async fn vcs_branch_info(host: &Host, window: &str, repo: Option<PathBuf>) -> IdeResult<BranchInfo> {
-    let project = host.project(window)?;
-    blocking(move || project.with_repo_at(repo.as_deref(), |r| r.branch_info())).await
+    let project = LogAccess::new(host, window, repo.as_deref());
+    blocking(move || project.with_log_repo_at(repo.as_deref(), |r| r.branch_info())).await
 }
 
 /// Gutter change markers for a file, computed against its current (unsaved) text.
@@ -197,9 +267,21 @@ pub async fn vcs_line_hunks(host: &Host, window: &str, path: PathBuf) -> IdeResu
 }
 
 pub async fn vcs_file_at(host: &Host, window: &str, path: PathBuf, rev: Option<String>) -> IdeResult<Option<String>> {
-    let project = host.project(window)?;
+    let project = host.project(window).ok();
+    let external = host.external_logs.read().get(host.owner_window(window)).and_then(|rs| {
+        rs.iter().filter(|r| path.starts_with(r.root())).max_by_key(|r| r.root().components().count()).cloned()
+    });
     blocking(move || {
-        project.with_repo_of(&path, |r| r.file_at(&path, rev.as_deref(), project.vcs_encoding(&path, rev.as_deref())?))
+        if let Some(project) = project {
+            return project.with_log_repo_of(&path, |r| {
+                r.file_at(&path, rev.as_deref(), project.vcs_encoding(&path, rev.as_deref())?)
+            });
+        }
+        external.ok_or_else(|| ide_core::IdeError::unavailable("external Git log is not open"))?.file_at(
+            &path,
+            rev.as_deref(),
+            encoding_rs::UTF_8,
+        )
     })
     .await
 }
@@ -222,9 +304,148 @@ pub async fn vcs_blame(
     .await
 }
 
-pub async fn vcs_log(host: &Host, window: &str, repo: Option<PathBuf>, query: LogQuery) -> IdeResult<Vec<Commit>> {
+/// History for Selection: the commits that changed `lines` (0-based, inclusive) of the
+/// editor's text of `path`. Cancellable.
+pub async fn vcs_block_history(
+    host: &Host,
+    window: &str,
+    request: RequestId,
+    path: PathBuf,
+    text: Option<String>,
+    lines: (u32, u32),
+) -> IdeResult<BlockHistory> {
     let project = host.project(window)?;
-    blocking(move || project.with_repo_at(repo.as_deref(), |r| r.log(&query))).await
+    let cancel = host.begin_request(request);
+    let result = blocking(move || {
+        let text = text.or_else(|| project.documents.text_of(&path));
+        project.with_repo_of(&path, |r| {
+            r.block_history(&path, text.as_deref(), lines, project.vcs_encoding(&path, None)?, &cancel)
+        })
+    })
+    .await;
+    host.end_request(request);
+    result
+}
+
+pub async fn vcs_log(host: &Host, window: &str, repo: Option<PathBuf>, query: LogQuery) -> IdeResult<Vec<Commit>> {
+    let project = LogAccess::new(host, window, repo.as_deref());
+    let request = query.request;
+    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);
+            r.log_cancellable(&query, &cancel)
+        })
+    })
+    .await;
+    if let Some(id) = request {
+        host.end_request(id);
+    }
+    result
+}
+
+pub async fn vcs_log_refs(
+    host: &Host,
+    window: &str,
+    repo: Option<PathBuf>,
+) -> IdeResult<std::collections::BTreeMap<String, String>> {
+    let project = LogAccess::new(host, window, repo.as_deref());
+    blocking(move || project.with_log_repo_at(repo.as_deref(), |r| r.log_refs())).await
+}
+
+pub async fn vcs_log_users(host: &Host, window: &str, repo: Option<PathBuf>) -> IdeResult<Vec<String>> {
+    let project = LogAccess::new(host, window, repo.as_deref());
+    blocking(move || project.with_log_repo_at(repo.as_deref(), |r| r.log_users())).await
+}
+
+pub async fn vcs_open_external_log(host: &Host, window: &str, path: PathBuf) -> IdeResult<ide_core::IpcPath> {
+    let path = dunce::canonicalize(path)?;
+    let repo = Repo::discover(&path)?.ok_or_else(|| ide_core::IdeError::unavailable("folder is not a Git worktree"))?;
+    let root = repo.root().to_path_buf();
+    repo.set_execution_allowed(false);
+    repo.enable_log_index(&host.local_data_dir.join("cache/git-log"));
+    if let Ok(project) = host.project(window) {
+        project.open_external_log(&root)?;
+    }
+    let mut logs = host.external_logs.write();
+    let roots = logs.entry(host.owner_window(window).to_string()).or_default();
+    if !roots.iter().any(|r| r.root() == root) {
+        roots.push(std::sync::Arc::new(repo));
+    }
+    Ok(root.into())
+}
+
+pub async fn vcs_log_details(
+    host: &Host,
+    window: &str,
+    repo: Option<PathBuf>,
+    revision: String,
+) -> IdeResult<LogDetails> {
+    let project = LogAccess::new(host, window, repo.as_deref());
+    blocking(move || project.with_log_repo_at(repo.as_deref(), |r| r.log_details(&revision))).await
+}
+
+pub async fn vcs_log_details_batch(
+    host: &Host,
+    window: &str,
+    repo: Option<PathBuf>,
+    revisions: Vec<String>,
+    request: RequestId,
+) -> IdeResult<Vec<LogDetails>> {
+    let project = LogAccess::new(host, window, repo.as_deref());
+    let cancel = host.begin_project_read_request(window, request);
+    let result = blocking(move || {
+        project.with_log_repo_at(repo.as_deref(), |r| {
+            revisions.iter().map(|id| r.log_details_cancellable(id, &cancel)).collect()
+        })
+    })
+    .await;
+    host.end_request(request);
+    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,
+    repo: Option<PathBuf>,
+    revision: String,
+    directory: String,
+) -> IdeResult<Vec<String>> {
+    let project = LogAccess::new(host, window, repo.as_deref());
+    blocking(move || project.with_log_repo_at(repo.as_deref(), |r| r.revision_children(&revision, &directory))).await
+}
+
+pub async fn vcs_revision_files(
+    host: &Host,
+    window: &str,
+    repo: Option<PathBuf>,
+    revision: String,
+) -> IdeResult<Vec<String>> {
+    let project = LogAccess::new(host, window, repo.as_deref());
+    blocking(move || project.with_log_repo_at(repo.as_deref(), |r| r.revision_files(&revision))).await
 }
 
 pub async fn vcs_commit_files(
@@ -233,8 +454,8 @@ pub async fn vcs_commit_files(
     repo: Option<PathBuf>,
     commit: String,
 ) -> IdeResult<Vec<ChangedFile>> {
-    let project = host.project(window)?;
-    blocking(move || project.with_repo_at(repo.as_deref(), |r| r.commit_files(&commit))).await
+    let project = LogAccess::new(host, window, repo.as_deref());
+    blocking(move || project.with_log_repo_at(repo.as_deref(), |r| r.commit_files(&commit))).await
 }
 
 /// Combined changes of several commits, `commits` oldest first.
@@ -244,13 +465,13 @@ pub async fn vcs_commits_changes(
     repo: Option<PathBuf>,
     commits: Vec<String>,
 ) -> IdeResult<Vec<RevisionChange>> {
-    let project = host.project(window)?;
-    blocking(move || project.with_repo_at(repo.as_deref(), |r| r.commits_changes(&commits))).await
+    let project = LogAccess::new(host, window, repo.as_deref());
+    blocking(move || project.with_log_repo_at(repo.as_deref(), |r| r.commits_changes(&commits))).await
 }
 
 pub async fn vcs_branches(host: &Host, window: &str, repo: Option<PathBuf>) -> IdeResult<Vec<Branch>> {
-    let project = host.project(window)?;
-    blocking(move || project.with_repo_at(repo.as_deref(), |r| r.branches())).await
+    let project = LogAccess::new(host, window, repo.as_deref());
+    blocking(move || project.with_log_repo_at(repo.as_deref(), |r| r.branches())).await
 }
 
 pub async fn vcs_stashes(host: &Host, window: &str, repo: Option<PathBuf>) -> IdeResult<Vec<Stash>> {
@@ -605,8 +826,8 @@ pub async fn vcs_config_get(
     repo: Option<PathBuf>,
     key: String,
 ) -> IdeResult<Option<String>> {
-    let project = host.project(window)?;
-    blocking(move || project.with_repo_at(repo.as_deref(), |r| r.config_get(&key))).await
+    let project = LogAccess::new(host, window, repo.as_deref());
+    blocking(move || project.with_log_repo_at(repo.as_deref(), |r| r.config_get(&key))).await
 }
 
 /// Local history operation that may take a while (hooks, large checkouts); git's
@@ -667,8 +888,8 @@ pub async fn vcs_create_tag(
 }
 
 pub async fn vcs_tags(host: &Host, window: &str, repo: Option<PathBuf>) -> IdeResult<Vec<String>> {
-    let project = host.project(window)?;
-    blocking(move || project.with_repo_at(repo.as_deref(), |r| r.tags())).await
+    let project = LogAccess::new(host, window, repo.as_deref());
+    blocking(move || project.with_log_repo_at(repo.as_deref(), |r| r.tags())).await
 }
 
 /// Merge dialog: merges `branches` into the current branch.
@@ -704,8 +925,8 @@ pub async fn vcs_rebase_with(
 }
 
 pub async fn vcs_remotes(host: &Host, window: &str, repo: Option<PathBuf>) -> IdeResult<Vec<Remote>> {
-    let project = host.project(window)?;
-    blocking(move || project.with_repo_at(repo.as_deref(), |r| r.remotes())).await
+    let project = LogAccess::new(host, window, repo.as_deref());
+    blocking(move || project.with_log_repo_at(repo.as_deref(), |r| r.remotes())).await
 }
 
 pub async fn vcs_edit_remote(host: &Host, window: &str, repo: Option<PathBuf>, edit: RemoteEdit) -> IdeResult<()> {
@@ -792,8 +1013,8 @@ pub async fn vcs_diff_with_worktree(
     repo: Option<PathBuf>,
     rev: String,
 ) -> IdeResult<Vec<ChangedFile>> {
-    let project = host.project(window)?;
-    blocking(move || project.with_repo_at(repo.as_deref(), |r| r.diff_with_worktree(&rev))).await
+    let project = LogAccess::new(host, window, repo.as_deref());
+    blocking(move || project.with_log_repo_at(repo.as_deref(), |r| r.diff_with_worktree(&rev))).await
 }
 
 /// Files that differ between two revisions (the "N files updated" of Update Project).
@@ -804,8 +1025,8 @@ pub async fn vcs_diff_revisions(
     from: String,
     to: String,
 ) -> IdeResult<Vec<ChangedFile>> {
-    let project = host.project(window)?;
-    blocking(move || project.with_repo_at(repo.as_deref(), |r| r.diff_revisions(&from, &to))).await
+    let project = LogAccess::new(host, window, repo.as_deref());
+    blocking(move || project.with_log_repo_at(repo.as_deref(), |r| r.diff_revisions(&from, &to))).await
 }
 
 /// The best common ancestor of `a` and `b` (`git merge-base`), if any: the New Pull
@@ -987,7 +1208,30 @@ pub(crate) fn register(d: &mut Dispatcher) {
     d.add("vcs_blame", |c| async move {
         vcs_blame(&c.host, &c.window, c.arg("path")?, c.arg("text")?, c.arg("revision")?).await
     });
+    d.add("vcs_block_history", |c| async move {
+        let (request, path, text, lines) = (c.arg("request")?, c.arg("path")?, c.arg("text")?, c.arg("lines")?);
+        vcs_block_history(&c.host, &c.window, request, path, text, lines).await
+    });
     d.add("vcs_log", |c| async move { vcs_log(&c.host, &c.window, c.arg("repo")?, c.arg("query")?).await });
+    d.add("vcs_log_refs", |c| async move { vcs_log_refs(&c.host, &c.window, c.arg("repo")?).await });
+    d.add("vcs_log_users", |c| async move { vcs_log_users(&c.host, &c.window, c.arg("repo")?).await });
+    d.add("vcs_open_external_log", |c| async move { vcs_open_external_log(&c.host, &c.window, c.arg("path")?).await });
+    d.add("vcs_log_details", |c| async move {
+        vcs_log_details(&c.host, &c.window, c.arg("repo")?, c.arg("revision")?).await
+    });
+    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
+    });
+    d.add("vcs_revision_files", |c| async move {
+        vcs_revision_files(&c.host, &c.window, c.arg("repo")?, c.arg("revision")?).await
+    });
     d.add("vcs_commit_files", |c| async move {
         vcs_commit_files(&c.host, &c.window, c.arg("repo")?, c.arg("commit")?).await
     });

crates/ide-host/src/plugins/api.rs

@@ -0,0 +1,814 @@
+//! [`HostApi`] for one plugin's code: what its imports reach in the IDE.
+//! Capabilities were checked by the runtime before any of this runs.
+
+use super::{PluginEvent, PluginEventSink};
+use ide_core::{CancellationToken, TextEdit};
+use ide_extension::Package;
+use ide_language::ProgramPin;
+use ide_plugin::{
+    EventKind, HostApi, HostError, HttpRequest, HttpResponse, NotificationLevel, ProcessOutput, RepositoryStatus,
+    StatusItem,
+};
+use parking_lot::{Mutex, RwLock};
+use std::collections::{BTreeMap, BTreeSet, HashMap};
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::{Duration, Instant};
+
+/// Largest storage of one plugin (keys + values).
+const MAX_STORAGE: usize = 1 << 20;
+const MAX_KEY: usize = 256;
+/// Most status bar items per plugin.
+const MAX_STATUS_ITEMS: usize = 8;
+
+/// What plugins see of the open projects; provided by the app
+/// ([`super::PluginHost::set_workspace`]), over [`crate::Host`] on the desktop.
+pub trait PluginWorkspace: Send + Sync {
+    /// Roots of the open projects.
+    fn projects(&self) -> Vec<PathBuf>;
+    /// Unsaved text of the open document at `path`.
+    fn buffer_text(&self, path: &Path) -> Option<String>;
+    /// Version and text of the open document at `path`.
+    fn document(&self, path: &Path) -> Option<(u64, String)>;
+    /// Applies `edits` to the open document at `path` if it is still at
+    /// `version`, as one change (one undo step in the editor).
+    fn apply_edits(&self, path: &Path, version: u64, edits: &[TextEdit]) -> Result<u64, HostError>;
+    /// Code from the project may run (git hooks and config on fetch).
+    fn trusted(&self, root: &Path) -> bool;
+    /// Root of the project open in `window`.
+    fn project_of(&self, window: &str) -> Option<PathBuf>;
+    /// Shows `items` as producer `source`'s diagnostics of `path` (replacing earlier ones).
+    fn publish_diagnostics(&self, source: &str, path: &Path, items: Vec<ide_core::Diagnostic>)
+    -> Result<(), HostError>;
+    /// The user's values of `plugin`'s settings: the project's at `root`
+    /// (over global), or global.
+    fn plugin_settings(&self, _plugin: &str, _root: Option<&Path>) -> serde_json::Map<String, serde_json::Value> {
+        serde_json::Map::new()
+    }
+}
+
+/// Where plugin secrets live (the OS keychain on the desktop). Plugins can
+/// only ask whether one is set; values go out only inside `net` requests.
+pub trait SecretStore: Send + Sync {
+    fn get(&self, plugin: &str, name: &str) -> Option<String>;
+    /// Sets, or (`None`) deletes.
+    fn set(&self, plugin: &str, name: &str, value: Option<&str>) -> Result<(), String>;
+}
+
+/// Fallback [`SecretStore`]: one file per plugin, readable only by the user.
+pub struct FileSecretStore {
+    pub dir: PathBuf,
+}
+
+impl FileSecretStore {
+    fn file(&self, plugin: &str) -> PathBuf {
+        self.dir.join(plugin).join("secrets.json")
+    }
+
+    fn load(&self, plugin: &str) -> BTreeMap<String, String> {
+        std::fs::read(self.file(plugin)).ok().and_then(|b| serde_json::from_slice(&b).ok()).unwrap_or_default()
+    }
+}
+
+impl SecretStore for FileSecretStore {
+    fn get(&self, plugin: &str, name: &str) -> Option<String> {
+        self.load(plugin).remove(name)
+    }
+
+    fn set(&self, plugin: &str, name: &str, value: Option<&str>) -> Result<(), String> {
+        let mut map = self.load(plugin);
+        match value {
+            Some(v) => map.insert(name.to_owned(), v.to_owned()),
+            None => map.remove(name),
+        };
+        let file = self.file(plugin);
+        std::fs::create_dir_all(file.parent().expect("has parent")).map_err(|e| e.to_string())?;
+        let bytes = serde_json::to_vec(&map).map_err(|e| e.to_string())?;
+        let tmp = file.with_extension("tmp");
+        std::fs::write(&tmp, bytes).map_err(|e| e.to_string())?;
+        #[cfg(unix)]
+        {
+            use std::os::unix::fs::PermissionsExt;
+            let _ = std::fs::set_permissions(&tmp, std::fs::Permissions::from_mode(0o600));
+        }
+        std::fs::rename(&tmp, &file).map_err(|e| e.to_string())
+    }
+}
+
+/// Largest response body a plugin receives.
+const MAX_RESPONSE: usize = 8 << 20;
+/// Largest stdout / stderr kept from a process.
+const MAX_OUTPUT: usize = 4 << 20;
+/// Most files `find-files` walks before giving up.
+const MAX_WALK: usize = 200_000;
+
+/// Runtime for plugin HTTP requests (actor threads block on it).
+pub(super) fn net_runtime() -> &'static tokio::runtime::Runtime {
+    static RT: std::sync::OnceLock<tokio::runtime::Runtime> = std::sync::OnceLock::new();
+    RT.get_or_init(|| {
+        tokio::runtime::Builder::new_multi_thread()
+            .worker_threads(2)
+            .thread_name("plugin-net")
+            .enable_all()
+            .build()
+            .expect("plugin network runtime")
+    })
+}
+
+/// Replaces `{{secret:<name>}}` in `value` with the plugin's secrets.
+fn fill_secrets(value: &str, lookup: impl Fn(&str) -> Option<String>) -> Result<String, HostError> {
+    let mut out = String::with_capacity(value.len());
+    let mut rest = value;
+    while let Some(i) = rest.find("{{secret:") {
+        out.push_str(&rest[..i]);
+        let after = &rest[i + "{{secret:".len()..];
+        let end = after.find("}}").ok_or_else(|| HostError::Invalid("unterminated {{secret:…}}".into()))?;
+        let name = &after[..end];
+        let secret = lookup(name).ok_or_else(|| HostError::NotFound(format!("secret {name:?} is not set")))?;
+        out.push_str(&secret);
+        rest = &after[end + 2..];
+    }
+    out.push_str(rest);
+    Ok(out)
+}
+
+/// A plugin task shown in the UI.
+struct TaskEntry {
+    plugin: String,
+    cancel: CancellationToken,
+    cancelled: bool,
+}
+
+/// State shared by the host and every plugin's [`PluginApi`].
+pub(super) struct Shared {
+    pub sink: Arc<dyn PluginEventSink>,
+    pub workspace: RwLock<Option<Arc<dyn PluginWorkspace>>>,
+    /// `<plugins>/.data`: one directory per plugin id.
+    pub data_dir: PathBuf,
+    tasks: Mutex<HashMap<u64, TaskEntry>>,
+    next_task: AtomicU64,
+    /// (plugin, item id) → item, for windows opened later.
+    status: Mutex<BTreeMap<(String, String), StatusItem>>,
+    /// plugin → kinds subscribed at run time (kept across idle reclaim).
+    pub subscriptions: Mutex<HashMap<String, BTreeSet<EventKind>>>,
+    /// plugin → files it shows problems for, withdrawn when it stops.
+    diagnostics: Mutex<HashMap<String, BTreeSet<PathBuf>>>,
+    pub secrets: RwLock<Arc<dyn SecretStore>>,
+    /// (plugin, `process:` capability) → the approved program.
+    pub pins: Arc<RwLock<HashMap<(String, String), ProgramPin>>>,
+    /// Validated UI declarations (settings schemas, declared views).
+    pub ui: Arc<ide_extension::UiStore>,
+}
+
+impl Shared {
+    pub fn new(
+        sink: Arc<dyn PluginEventSink>,
+        data_dir: PathBuf,
+        pins: Arc<RwLock<HashMap<(String, String), ProgramPin>>>,
+        ui: Arc<ide_extension::UiStore>,
+    ) -> Arc<Self> {
+        Arc::new(Self {
+            ui,
+            sink,
+            workspace: RwLock::new(None),
+            secrets: RwLock::new(Arc::new(FileSecretStore { dir: data_dir.clone() })),
+            pins,
+            data_dir,
+            tasks: Mutex::default(),
+            next_task: AtomicU64::new(1),
+            status: Mutex::default(),
+            subscriptions: Mutex::default(),
+            diagnostics: Mutex::default(),
+        })
+    }
+
+    fn workspace(&self) -> Option<Arc<dyn PluginWorkspace>> {
+        self.workspace.read().clone()
+    }
+
+    pub fn project_of(&self, window: &str) -> Option<PathBuf> {
+        self.workspace()?.project_of(window)
+    }
+
+    /// Shows `plugin`'s problems of `path`, remembering the file until they are
+    /// cleared (by the plugin, or when it stops).
+    fn publish_diagnostics(
+        &self,
+        plugin: &str,
+        path: &Path,
+        items: Vec<ide_core::Diagnostic>,
+    ) -> Result<(), HostError> {
+        let workspace = self.workspace().ok_or_else(|| HostError::NotFound("no project is open".into()))?;
+        let empty = items.is_empty();
+        workspace.publish_diagnostics(plugin, path, items)?;
+        let mut published = self.diagnostics.lock();
+        if empty {
+            if let Some(paths) = published.get_mut(plugin) {
+                paths.remove(path);
+                if paths.is_empty() {
+                    published.remove(plugin);
+                }
+            }
+        } else {
+            published.entry(plugin.to_owned()).or_default().insert(path.to_path_buf());
+        }
+        Ok(())
+    }
+
+    pub fn status_items(&self) -> Vec<(String, String, StatusItem)> {
+        self.status.lock().iter().map(|((p, id), item)| (p.clone(), id.clone(), item.clone())).collect()
+    }
+
+    /// Withdraws a plugin's run-time state (it stopped or failed). Its
+    /// subscriptions go only with `subscriptions`, as they survive restarts.
+    pub fn clear_plugin(&self, plugin: &str, subscriptions: bool) {
+        let removed: Vec<String> = {
+            let mut status = self.status.lock();
+            let ids: Vec<String> = status.keys().filter(|(p, _)| p == plugin).map(|(_, id)| id.clone()).collect();
+            for id in &ids {
+                status.remove(&(plugin.to_owned(), id.clone()));
+            }
+            ids
+        };
+        for id in removed {
+            self.sink.emit(None, PluginEvent::StatusItemChanged { plugin_id: plugin.to_owned(), id, item: None });
+        }
+        let tasks: Vec<u64> = self.tasks.lock().iter().filter(|(_, t)| t.plugin == plugin).map(|(id, _)| *id).collect();
+        for id in tasks {
+            self.end_task(id);
+        }
+        // Its problems go with it (an idle reclaim keeps them: it isn't cleared then).
+        let paths = self.diagnostics.lock().remove(plugin).unwrap_or_default();
+        if let Some(workspace) = self.workspace() {
+            for path in paths {
+                let _ = workspace.publish_diagnostics(plugin, &path, Vec::new());
+            }
+        }
+        if subscriptions && self.subscriptions.lock().remove(plugin).is_some() {
+            self.sink.emit(None, PluginEvent::SubscriptionsChanged);
+        }
+    }
+
+    /// The user cancelled a task in the UI.
+    pub fn cancel_task(&self, id: u64) -> bool {
+        let mut tasks = self.tasks.lock();
+        let Some(t) = tasks.get_mut(&id) else { return false };
+        t.cancelled = true;
+        t.cancel.cancel();
+        true
+    }
+
+    fn end_task(&self, id: u64) {
+        if let Some(t) = self.tasks.lock().remove(&id) {
+            self.sink.emit(None, PluginEvent::TaskEnded { plugin_id: t.plugin, task_id: id.to_string() });
+        }
+    }
+
+    pub fn storage_file(&self, plugin: &str) -> PathBuf {
+        self.data_dir.join(plugin).join("storage.json")
+    }
+}
+
+pub(super) struct PluginApi {
+    pub pkg: Package,
+    pub shared: Arc<Shared>,
+}
+
+impl PluginApi {
+    fn id(&self) -> &str {
+        self.pkg.id()
+    }
+
+    fn load_storage(&self) -> Result<BTreeMap<String, String>, HostError> {
+        match std::fs::read(self.shared.storage_file(self.id())) {
+            Ok(bytes) => serde_json::from_slice(&bytes).map_err(|e| HostError::Failed(format!("storage: {e}"))),
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(BTreeMap::new()),
+            Err(e) => Err(HostError::Failed(format!("storage: {e}"))),
+        }
+    }
+
+    fn save_storage(&self, map: &BTreeMap<String, String>) -> Result<(), HostError> {
+        let file = self.shared.storage_file(self.id());
+        let bytes = serde_json::to_vec(map).map_err(|e| HostError::Failed(e.to_string()))?;
+        let io = |e: std::io::Error| HostError::Failed(format!("storage: {e}"));
+        std::fs::create_dir_all(file.parent().expect("has parent")).map_err(io)?;
+        let tmp = file.with_extension("tmp");
+        std::fs::write(&tmp, bytes).and_then(|()| std::fs::rename(&tmp, &file)).map_err(io)
+    }
+
+    /// The program approved for the (already checked) `process:` grant,
+    /// verified right before it starts.
+    fn approved_program(&self, program: &str) -> Result<PathBuf, HostError> {
+        let cap = format!("process:{program}");
+        // Granted without a pinned file: the program wasn't found when it was
+        // allowed, and installing it later approves nothing by itself.
+        let pin = self.shared.pins.read().get(&(self.id().to_owned(), cap.clone())).cloned().ok_or_else(|| {
+            HostError::Failed(format!(
+                "{cap}: `{program}` was not found when this permission was allowed; \
+                 install it, then allow {cap} again in Settings › Plugins"
+            ))
+        })?;
+        pin.verify().map(Path::to_path_buf).map_err(|e| HostError::Denied(format!("{cap}: {e}")))
+    }
+}
+
+fn failed(e: impl std::fmt::Display) -> HostError {
+    HostError::Failed(e.to_string())
+}
+
+impl HostApi for PluginApi {
+    fn notify(&self, client: Option<&str>, level: NotificationLevel, title: String, body: String) {
+        self.shared
+            .sink
+            .emit(client, PluginEvent::Notification { plugin_id: self.id().to_owned(), level, title, body });
+    }
+
+    fn status_item(&self, id: &str, item: Option<StatusItem>) {
+        let key = (self.id().to_owned(), id.to_owned());
+        {
+            let mut status = self.shared.status.lock();
+            match &item {
+                Some(item) => {
+                    let count = status.keys().filter(|(p, _)| p == self.id()).count();
+                    if !status.contains_key(&key) && count >= MAX_STATUS_ITEMS {
+                        tracing::warn!(plugin = %self.id(), "more than {MAX_STATUS_ITEMS} status items; {id:?} ignored");
+                        return;
+                    }
+                    if status.get(&key) == Some(item) {
+                        return;
+                    }
+                    status.insert(key, item.clone());
+                }
+                None => {
+                    if status.remove(&key).is_none() {
+                        return;
+                    }
+                }
+            }
+        }
+        self.shared
+            .sink
+            .emit(None, PluginEvent::StatusItemChanged { plugin_id: self.id().to_owned(), id: id.to_owned(), item });
+    }
+
+    fn projects(&self) -> Vec<PathBuf> {
+        self.shared.workspace().map(|w| w.projects()).unwrap_or_default()
+    }
+
+    fn buffer_text(&self, path: &Path) -> Option<String> {
+        self.shared.workspace()?.buffer_text(path)
+    }
+
+    fn document(&self, path: &Path) -> Option<(u64, String)> {
+        self.shared.workspace()?.document(path)
+    }
+
+    fn apply_edits(
+        &self,
+        _client: Option<&str>,
+        path: &Path,
+        version: u64,
+        edits: Vec<TextEdit>,
+    ) -> Result<u64, HostError> {
+        let workspace = self.shared.workspace().ok_or_else(|| HostError::NotFound("no project is open".into()))?;
+        workspace.apply_edits(path, version, &edits)
+    }
+
+    fn storage_get(&self, key: &str) -> Result<Option<String>, HostError> {
+        Ok(self.load_storage()?.get(key).cloned())
+    }
+
+    fn storage_set(&self, key: &str, value: Option<String>) -> Result<(), HostError> {
+        if key.is_empty() || key.len() > MAX_KEY {
+            return Err(HostError::Invalid(format!("keys are 1–{MAX_KEY} bytes")));
+        }
+        let mut map = self.load_storage()?;
+        let changed = match value {
+            Some(v) => map.insert(key.to_owned(), v.clone()).as_ref() != Some(&v),
+            None => map.remove(key).is_some(),
+        };
+        if !changed {
+            return Ok(());
+        }
+        let size: usize = map.iter().map(|(k, v)| k.len() + v.len()).sum();
+        if size > MAX_STORAGE {
+            return Err(HostError::Invalid(format!("storage is limited to {} KiB", MAX_STORAGE >> 10)));
+        }
+        self.save_storage(&map)
+    }
+
+    fn storage_keys(&self, prefix: &str) -> Result<Vec<String>, HostError> {
+        Ok(self.load_storage()?.into_keys().filter(|k| k.starts_with(prefix)).collect())
+    }
+
+    fn vcs_status(&self, root: &Path) -> Result<Option<RepositoryStatus>, HostError> {
+        let Some(repo) = ide_vcs::Repo::discover(root).map_err(failed)? else { return Ok(None) };
+        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(),
+            branch: info.head,
+            commit: info.head_commit,
+            upstream: info.upstream,
+            ahead: info.ahead,
+            behind: info.behind,
+            operation: info.operation,
+            changed_files: u32::try_from(changed).unwrap_or(u32::MAX),
+        }))
+    }
+
+    fn vcs_fetch(&self, root: &Path, cancel: &CancellationToken) -> Result<(), HostError> {
+        let workspace = self.shared.workspace();
+        if !workspace.is_some_and(|w| w.trusted(root)) {
+            return Err(HostError::Failed("the project is in Restricted Mode: git does not run there".into()));
+        }
+        let Some(repo) = ide_vcs::Repo::discover(root).map_err(failed)? else {
+            return Err(HostError::NotFound("the project is not in a git repository".into()));
+        };
+        match repo.fetch(cancel, &|_| {}) {
+            Ok(()) => Ok(()),
+            Err(_) if cancel.is_cancelled() => Err(HostError::Cancelled),
+            Err(e) => Err(failed(e.message)),
+        }
+    }
+
+    fn find_files(&self, root: &Path, glob: &str, limit: usize) -> Result<Vec<String>, HostError> {
+        let matcher = globset::GlobBuilder::new(glob)
+            .literal_separator(true)
+            .build()
+            .map_err(|e| HostError::Invalid(format!("{glob:?}: {e}")))?
+            .compile_matcher();
+        let mut out = Vec::new();
+        for (n, entry) in ignore::WalkBuilder::new(root).hidden(true).build().flatten().enumerate() {
+            if n >= MAX_WALK || out.len() >= limit {
+                break;
+            }
+            if !entry.file_type().is_some_and(|t| t.is_file()) {
+                continue;
+            }
+            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.sort();
+        Ok(out)
+    }
+
+    fn publish_diagnostics(&self, path: &Path, items: Vec<ide_core::Diagnostic>) -> Result<(), HostError> {
+        self.shared.publish_diagnostics(self.id(), path, items)
+    }
+
+    fn fetch(&self, request: HttpRequest, cancel: &CancellationToken) -> Result<HttpResponse, HostError> {
+        let secrets = self.shared.secrets.read().clone();
+        let id = self.id().to_owned();
+        let mut headers = reqwest::header::HeaderMap::new();
+        for (name, value) in &request.headers {
+            let value = fill_secrets(value, |n| secrets.get(&id, n))?;
+            let name = reqwest::header::HeaderName::from_bytes(name.as_bytes())
+                .map_err(|e| HostError::Invalid(format!("header {name:?}: {e}")))?;
+            let mut value = reqwest::header::HeaderValue::from_str(&value)
+                .map_err(|e| HostError::Invalid(format!("header {name}: {e}")))?;
+            value.set_sensitive(true);
+            headers.append(name, value);
+        }
+        let method = reqwest::Method::from_bytes(request.method.to_ascii_uppercase().as_bytes())
+            .map_err(|_| HostError::Invalid(format!("method {:?}", request.method)))?;
+        let client = ide_http::client::shared().map_err(|e| HostError::Failed(e.message))?;
+        // A redirect to another host is refused after the fact (the shared
+        // client follows redirects).
+        let builder = client.request(method, &request.url).headers(headers).timeout(request.timeout);
+        let builder = match request.body {
+            Some(body) => builder.body(body),
+            None => builder,
+        };
+        let cancel = cancel.clone();
+        let host = ide_plugin::net_host(&request.url).map_err(HostError::Invalid)?;
+        net_runtime().block_on(async move {
+            let send = async {
+                let response = builder.send().await.map_err(|e| HostError::Failed(e.to_string()))?;
+                if ide_plugin::net_host(response.url().as_str()).ok().as_deref() != Some(host.as_str()) {
+                    return Err(HostError::Denied(format!(
+                        "net:{} (redirected)",
+                        response.url().host_str().unwrap_or("?")
+                    )));
+                }
+                let status = response.status().as_u16();
+                let headers = response
+                    .headers()
+                    .iter()
+                    .map(|(k, v)| (k.as_str().to_owned(), String::from_utf8_lossy(v.as_bytes()).into_owned()))
+                    .collect();
+                let mut body = Vec::new();
+                let mut response = response;
+                while let Some(chunk) = response.chunk().await.map_err(|e| HostError::Failed(e.to_string()))? {
+                    if body.len() + chunk.len() > MAX_RESPONSE {
+                        return Err(HostError::Failed("response larger than 8 MiB".into()));
+                    }
+                    body.extend_from_slice(&chunk);
+                }
+                Ok(HttpResponse { status, headers, body })
+            };
+            tokio::select! {
+                r = send => r,
+                () = cancel.cancelled() => Err(HostError::Cancelled),
+            }
+        })
+    }
+
+    fn secret_is_set(&self, name: &str) -> bool {
+        self.shared.secrets.read().get(self.id(), name).is_some()
+    }
+
+    fn run_process(
+        &self,
+        program: &str,
+        args: Vec<String>,
+        cwd: Option<&Path>,
+        stdin: Option<String>,
+        cancel: &CancellationToken,
+        timeout: Duration,
+    ) -> Result<ProcessOutput, HostError> {
+        let binary = self.approved_program(program)?;
+        let cwd = cwd.map(Path::to_path_buf).unwrap_or_else(|| self.shared.data_dir.join(self.id()));
+        let _ = std::fs::create_dir_all(&cwd);
+        let mut child = std::process::Command::new(&binary)
+            .args(&args)
+            .current_dir(&cwd)
+            .stdin(if stdin.is_some() { std::process::Stdio::piped() } else { std::process::Stdio::null() })
+            .stdout(std::process::Stdio::piped())
+            .stderr(std::process::Stdio::piped())
+            .spawn()
+            .map_err(|e| HostError::Failed(format!("{}: {e}", binary.display())))?;
+        if let (Some(input), Some(mut pipe)) = (stdin, child.stdin.take()) {
+            std::thread::spawn(move || {
+                use std::io::Write;
+                let _ = pipe.write_all(input.as_bytes());
+            });
+        }
+        let read = |pipe: Option<Box<dyn std::io::Read + Send>>| {
+            std::thread::spawn(move || {
+                use std::io::Read;
+                let mut out = Vec::new();
+                if let Some(p) = pipe {
+                    let _ = p.take(MAX_OUTPUT as u64).read_to_end(&mut out);
+                }
+                String::from_utf8_lossy(&out).into_owned()
+            })
+        };
+        let stdout = read(child.stdout.take().map(|p| Box::new(p) as Box<dyn std::io::Read + Send>));
+        let stderr = read(child.stderr.take().map(|p| Box::new(p) as Box<dyn std::io::Read + Send>));
+        let deadline = Instant::now() + timeout;
+        let status = loop {
+            if let Some(status) = child.try_wait().map_err(|e| HostError::Failed(e.to_string()))? {
+                break status;
+            }
+            if cancel.is_cancelled() || Instant::now() >= deadline {
+                let _ = child.kill();
+                let _ = child.wait();
+                return Err(if cancel.is_cancelled() {
+                    HostError::Cancelled
+                } else {
+                    HostError::Failed(format!("{program} timed out after {timeout:?}"))
+                });
+            }
+            std::thread::sleep(Duration::from_millis(10));
+        };
+        Ok(ProcessOutput {
+            status: status.code(),
+            stdout: stdout.join().unwrap_or_default(),
+            stderr: stderr.join().unwrap_or_default(),
+        })
+    }
+
+    fn subscribe(&self, kind: EventKind, on: bool) {
+        let changed = {
+            let mut subs = self.shared.subscriptions.lock();
+            let set = subs.entry(self.id().to_owned()).or_default();
+            if on { set.insert(kind) } else { set.remove(&kind) }
+        };
+        if changed {
+            self.shared.sink.emit(None, PluginEvent::SubscriptionsChanged);
+        }
+    }
+
+    fn task_begin(&self, client: Option<&str>, title: String, cancellable: bool, cancel: CancellationToken) -> u64 {
+        let id = self.shared.next_task.fetch_add(1, Ordering::Relaxed);
+        self.shared.tasks.lock().insert(id, TaskEntry { plugin: self.id().to_owned(), cancel, cancelled: false });
+        self.shared.sink.emit(
+            client,
+            PluginEvent::TaskStarted { plugin_id: self.id().to_owned(), task_id: id.to_string(), title, cancellable },
+        );
+        id
+    }
+
+    fn task_report(&self, id: u64, done: u32, total: Option<u32>, message: Option<String>) {
+        if !self.shared.tasks.lock().contains_key(&id) {
+            return;
+        }
+        self.shared.sink.emit(
+            None,
+            PluginEvent::TaskProgress {
+                plugin_id: self.id().to_owned(),
+                task_id: id.to_string(),
+                done,
+                total,
+                message,
+            },
+        );
+    }
+
+    fn task_cancelled(&self, id: u64) -> bool {
+        self.shared.tasks.lock().get(&id).is_some_and(|t| t.cancelled)
+    }
+
+    fn task_end(&self, id: u64) {
+        self.shared.end_task(id);
+    }
+
+    fn refresh_view(&self, view: &str) {
+        self.shared
+            .sink
+            .emit(None, PluginEvent::ViewChanged { plugin_id: self.id().to_owned(), view: view.to_owned() });
+    }
+
+    fn post_view_message(&self, view: &str, message: String) -> Result<(), HostError> {
+        let declared = [super::ui_points::VIEWS, super::ui_points::CUSTOM_EDITORS]
+            .iter()
+            .any(|point| self.shared.ui.items(point, Some(self.id())).iter().any(|i| i.key == view));
+        if !declared {
+            return Err(HostError::NotFound(format!("the plugin declares no view {view:?}")));
+        }
+        let event = PluginEvent::ViewMessage { plugin_id: self.id().to_owned(), view: view.to_owned(), message };
+        self.shared.sink.emit(None, event);
+        Ok(())
+    }
+
+    fn open_terminal(
+        &self,
+        client: Option<&str>,
+        title: String,
+        program: &str,
+        args: Vec<String>,
+        cwd: Option<&Path>,
+    ) -> Result<(), HostError> {
+        let binary = self.approved_program(program)?;
+        let cwd = cwd.map(Path::to_path_buf).unwrap_or_else(|| self.shared.data_dir.join(self.id()));
+        let _ = std::fs::create_dir_all(&cwd);
+        let event = PluginEvent::OpenTerminal {
+            plugin_id: self.id().to_owned(),
+            title,
+            program: binary.into(),
+            args,
+            cwd: cwd.into(),
+        };
+        self.shared.sink.emit(client, event);
+        Ok(())
+    }
+
+    fn open_location(&self, client: Option<&str>, path: &Path, line: u32, column: u32) -> Result<(), HostError> {
+        let event = PluginEvent::OpenLocation {
+            plugin_id: self.id().to_owned(),
+            path: path.to_path_buf().into(),
+            line,
+            column,
+        };
+        self.shared.sink.emit(client, event);
+        Ok(())
+    }
+
+    fn setting(&self, root: Option<&Path>, key: &str) -> Option<String> {
+        let schema: Vec<super::ui_points::SettingSchema> = self
+            .shared
+            .ui
+            .items(super::ui_points::SETTINGS, Some(self.id()))
+            .into_iter()
+            .find_map(|i| serde_json::from_value(i.decl.get("properties")?.clone()).ok())?;
+        let setting = schema.into_iter().find(|s| s.key == key)?;
+        let user = self.shared.workspace().map(|w| w.plugin_settings(self.id(), root)).unwrap_or_default();
+        let value = user.get(key).filter(|v| setting.accepts(v)).cloned().unwrap_or(setting.default);
+        serde_json::to_string(&value).ok()
+    }
+}
+
+/// [`PluginWorkspace`] over the desktop host's open projects.
+pub struct HostWorkspace(pub std::sync::Weak<crate::Host>);
+
+impl HostWorkspace {
+    fn projects(&self) -> Vec<Arc<crate::project::Project>> {
+        self.0.upgrade().map(|h| h.projects()).unwrap_or_default()
+    }
+
+    /// The project holding an open document at `path`, and its id.
+    fn open_document(&self, path: &Path) -> Option<(Arc<crate::project::Project>, ide_core::DocId)> {
+        self.projects().into_iter().find_map(|p| p.documents.by_path(path).map(|doc| (p, doc)))
+    }
+}
+
+impl PluginWorkspace for HostWorkspace {
+    fn projects(&self) -> Vec<PathBuf> {
+        let mut roots: Vec<PathBuf> = HostWorkspace::projects(self).iter().map(|p| p.root.clone()).collect();
+        roots.sort();
+        roots.dedup();
+        roots
+    }
+
+    fn buffer_text(&self, path: &Path) -> Option<String> {
+        HostWorkspace::projects(self).iter().find_map(|p| p.documents.text_of(path))
+    }
+
+    fn document(&self, path: &Path) -> Option<(u64, String)> {
+        let (project, doc) = self.open_document(path)?;
+        let snap = project.documents.snapshot(doc).ok()?;
+        Some((u64::from(snap.version), snap.text))
+    }
+
+    fn apply_edits(&self, path: &Path, version: u64, edits: &[TextEdit]) -> Result<u64, HostError> {
+        let (project, doc) =
+            self.open_document(path).ok_or_else(|| HostError::NotFound(format!("{} is not open", path.display())))?;
+        let version = u32::try_from(version).map_err(|_| HostError::Stale)?;
+        match project.documents.apply_edits_at(doc, version, edits) {
+            Ok(Some(v)) => Ok(u64::from(v)),
+            Ok(None) => Err(HostError::Stale),
+            Err(e) if e.kind == ide_core::error::ErrorKind::InvalidInput => Err(HostError::Invalid(e.message)),
+            Err(e) => Err(HostError::Failed(e.message)),
+        }
+    }
+
+    fn trusted(&self, root: &Path) -> bool {
+        HostWorkspace::projects(self).iter().any(|p| p.root == root && p.is_trusted())
+    }
+
+    fn project_of(&self, window: &str) -> Option<PathBuf> {
+        self.0.upgrade()?.project(window).ok().map(|p| p.root.clone())
+    }
+
+    fn publish_diagnostics(
+        &self,
+        source: &str,
+        path: &Path,
+        items: Vec<ide_core::Diagnostic>,
+    ) -> Result<(), HostError> {
+        let projects = HostWorkspace::projects(self);
+        let project = projects
+            .iter()
+            .filter(|p| path.starts_with(&p.root))
+            .max_by_key(|p| p.root.as_os_str().len())
+            .ok_or_else(|| HostError::Invalid(format!("{} is not in an open project", path.display())))?;
+        project.sink.emit(ide_core::IdeEvent::Diagnostics {
+            path: path.to_path_buf().into(),
+            source: format!("plugin:{source}"),
+            items,
+        });
+        Ok(())
+    }
+
+    fn plugin_settings(&self, plugin: &str, root: Option<&Path>) -> serde_json::Map<String, serde_json::Value> {
+        let Some(host) = self.0.upgrade() else { return serde_json::Map::new() };
+        let settings = match root.and_then(|r| host.projects().into_iter().find(|p| p.root == r)) {
+            Some(p) => p.settings.effective(),
+            None => host.global_settings.effective(),
+        };
+        settings.plugins.get(plugin).cloned().unwrap_or_default()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn api(dir: &Path, pins: Arc<RwLock<HashMap<(String, String), ProgramPin>>>) -> PluginApi {
+        let manifest = ide_extension::Manifest::parse(
+            "id = \"acme.lint\"\nname = \"Lint\"\nversion = \"1.0.0\"\nengines.openidea = \"^1.0\"\n",
+        )
+        .unwrap();
+        let sink: Arc<dyn PluginEventSink> = Arc::new(|_: Option<&str>, _: PluginEvent| {});
+        let shared = Shared::new(sink, dir.join(".data"), pins, ide_extension::UiStore::new());
+        PluginApi { pkg: Package::new(manifest, dir.to_path_buf()), shared }
+    }
+
+    #[test]
+    fn programs_run_only_as_approved() {
+        let tmp = tempfile::tempdir().unwrap();
+        let bin = tmp.path().join("lint");
+        std::fs::write(&bin, "#!/bin/sh\n").unwrap();
+        let pins: Arc<RwLock<HashMap<(String, String), ProgramPin>>> = Arc::default();
+        let api = api(tmp.path(), pins.clone());
+
+        // Allowed while the program was missing: say how to fix it rather than "not granted".
+        let err = api.approved_program("lint").unwrap_err().to_string();
+        assert!(
+            err.contains("was not found when this permission was allowed") && err.contains("allow process:lint again"),
+            "{err}"
+        );
+
+        pins.write().insert(("acme.lint".into(), "process:lint".into()), ProgramPin::approve(&bin).unwrap());
+        assert_eq!(api.approved_program("lint").unwrap(), bin);
+
+        std::fs::write(&bin, "#!/bin/sh\necho replaced\n").unwrap();
+        assert!(
+            matches!(api.approved_program("lint"), Err(HostError::Denied(e)) if e.contains("changed since it was approved"))
+        );
+    }
+}

crates/ide-host/src/plugins/icon_extensions.rs

@@ -0,0 +1,207 @@
+use super::icon_patterns::validate_pattern;
+use ide_extension::validate_item_id;
+use serde::{Deserialize, Serialize};
+use std::collections::{BTreeMap, BTreeSet};
+use std::path::PathBuf;
+
+const MAX_GROUPS: usize = 64;
+const MAX_CHOICES: usize = 16;
+const MAX_CHOICE_OPTIONS: usize = 16;
+const MAX_NAME_LEN: usize = 255;
+pub(super) const DARK_SUFFIX: &str = "_dark";
+
+#[derive(Deserialize)]
+#[serde(untagged)]
+pub(super) enum IconDefinition {
+    Path(PathBuf),
+    Variants(IconVariants),
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct IconVariants {
+    light: PathBuf,
+    #[serde(default)]
+    dark: Option<PathBuf>,
+}
+
+impl IconDefinition {
+    pub(super) fn light(&self) -> &PathBuf {
+        match self {
+            IconDefinition::Path(p) => p,
+            IconDefinition::Variants(v) => &v.light,
+        }
+    }
+
+    pub(super) fn dark(&self) -> Option<&PathBuf> {
+        match self {
+            IconDefinition::Path(_) => None,
+            IconDefinition::Variants(v) => v.dark.as_ref(),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Default, PartialEq, Eq, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) enum Target {
+    #[default]
+    File,
+    Folder,
+}
+
+#[derive(Deserialize, Serialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub(super) struct Pattern {
+    pattern: String,
+    icon: String,
+    #[serde(default)]
+    target: Target,
+    #[serde(default)]
+    path: bool,
+    #[serde(default)]
+    ignore_case: bool,
+    #[serde(default)]
+    group: Option<String>,
+    #[serde(default)]
+    open_icon: Option<String>,
+}
+
+fn enabled_by_default() -> bool {
+    true
+}
+
+#[derive(Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct Group {
+    pub(super) id: String,
+    name: String,
+    #[serde(default = "enabled_by_default")]
+    enabled: bool,
+}
+
+#[derive(Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct ChoiceOption {
+    pub(super) id: String,
+    pub(super) name: String,
+    #[serde(default)]
+    overrides: BTreeMap<String, String>,
+}
+
+#[derive(Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct Choice {
+    pub(super) id: String,
+    pub(super) name: String,
+    pub(super) default: String,
+    pub(super) options: Vec<ChoiceOption>,
+}
+
+#[derive(Default, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct Extensions {
+    #[serde(default)]
+    pub(super) patterns: Vec<Pattern>,
+    #[serde(default)]
+    pub(super) overrides: BTreeMap<String, String>,
+    #[serde(default)]
+    pub(super) groups: Vec<Group>,
+    #[serde(default)]
+    pub(super) choices: Vec<Choice>,
+    #[serde(default)]
+    pub(super) accent: bool,
+}
+
+pub(super) fn check_icon_id(id: &str) -> Result<(), String> {
+    validate_item_id(id, "icon id")?;
+    if id.ends_with(DARK_SUFFIX) {
+        return Err(format!("icon id {id:?}: the {DARK_SUFFIX:?} suffix is reserved for dark variants"));
+    }
+    Ok(())
+}
+
+fn check_named(id: &str, name: &str, what: &str) -> Result<(), String> {
+    validate_item_id(id, what)?;
+    if name.trim().is_empty() || name.len() > MAX_NAME_LEN {
+        return Err(format!("{what} {id:?}: name must have 1 to {MAX_NAME_LEN} characters"));
+    }
+    Ok(())
+}
+
+fn check_unique<'a>(ids: impl Iterator<Item = &'a String>, what: &str) -> Result<(), String> {
+    let mut seen = BTreeSet::new();
+    match ids.into_iter().find(|id| !seen.insert(*id)) {
+        Some(id) => Err(format!("duplicate {what} {id:?}")),
+        None => Ok(()),
+    }
+}
+
+impl Extensions {
+    pub(super) fn mappings(&self) -> usize {
+        let chosen: usize = self.choices.iter().flat_map(|c| &c.options).map(|o| o.overrides.len()).sum();
+        self.patterns.len() + self.overrides.len() + chosen
+    }
+
+    pub(super) fn validate(&self, check_ref: &dyn Fn(&str, &str) -> Result<(), String>) -> Result<(), String> {
+        self.validate_groups()?;
+        for p in &self.patterns {
+            validate_pattern(&p.pattern)?;
+            check_ref(&p.icon, "patterns")?;
+            if let Some(group) = &p.group
+                && !self.groups.iter().any(|g| &g.id == group)
+            {
+                return Err(format!("pattern {:?}: unknown group {group:?}", p.pattern));
+            }
+            if let Some(open) = &p.open_icon {
+                if p.target != Target::Folder {
+                    return Err(format!("pattern {:?}: openIcon is only for folder patterns", p.pattern));
+                }
+                check_ref(open, "patterns")?;
+            }
+        }
+        check_overrides(&self.overrides, check_ref, "overrides")?;
+        for choice in &self.choices {
+            for option in &choice.options {
+                check_overrides(&option.overrides, check_ref, "choices")?;
+            }
+        }
+        Ok(())
+    }
+
+    fn validate_groups(&self) -> Result<(), String> {
+        if self.groups.len() > MAX_GROUPS || self.choices.len() > MAX_CHOICES {
+            return Err(format!("too many groups or choices (max {MAX_GROUPS} and {MAX_CHOICES})"));
+        }
+        for g in &self.groups {
+            check_named(&g.id, &g.name, "group")?;
+        }
+        check_unique(self.groups.iter().map(|g| &g.id), "group")?;
+        check_unique(self.choices.iter().map(|c| &c.id), "choice")?;
+        for choice in &self.choices {
+            check_named(&choice.id, &choice.name, "choice")?;
+            if choice.options.is_empty() || choice.options.len() > MAX_CHOICE_OPTIONS {
+                return Err(format!("choice {:?}: expected 1 to {MAX_CHOICE_OPTIONS} options", choice.id));
+            }
+            for option in &choice.options {
+                check_named(&option.id, &option.name, "choice option")?;
+            }
+            check_unique(choice.options.iter().map(|o| &o.id), "choice option")?;
+            if !choice.options.iter().any(|o| o.id == choice.default) {
+                return Err(format!("choice {:?}: default {:?} is not one of its options", choice.id, choice.default));
+            }
+        }
+        Ok(())
+    }
+}
+
+fn check_overrides(
+    overrides: &BTreeMap<String, String>,
+    check_ref: &dyn Fn(&str, &str) -> Result<(), String>,
+    what: &str,
+) -> Result<(), String> {
+    for (name, icon) in overrides {
+        validate_item_id(name, "overridden icon name")?;
+        check_ref(icon, what)?;
+    }
+    Ok(())
+}

crates/ide-host/src/plugins/icon_patterns.rs

@@ -0,0 +1,105 @@
+use regex_syntax::hir::{Hir, HirKind};
+
+pub(crate) const MAX_PATTERN_LEN: usize = 512;
+const NAME_LEN: u64 = 256;
+const MAX_COST: u64 = 4 * NAME_LEN * NAME_LEN;
+
+const UNSUPPORTED: &[(&str, &str)] = &[
+    ("\\A", "\\A"),
+    ("\\z", "\\z"),
+    ("\\Z", "\\Z"),
+    ("\\p", "\\p"),
+    ("\\P", "\\P"),
+    ("[[:", "a POSIX class"),
+    ("&&", "class intersection"),
+    ("~~", "class symmetric difference"),
+];
+
+pub(crate) fn validate_pattern(pattern: &str) -> Result<(), String> {
+    if pattern.len() > MAX_PATTERN_LEN {
+        return Err(format!("pattern {pattern:?} is too long (max {MAX_PATTERN_LEN})"));
+    }
+    if let Some(construct) = unsupported_construct(pattern) {
+        return Err(format!("pattern {pattern:?}: {construct} is not supported"));
+    }
+    let hir = regex_syntax::Parser::new().parse(pattern).map_err(|e| format!("invalid pattern {pattern:?}: {e}"))?;
+    match cost(&hir) {
+        Err(why) => Err(format!("pattern {pattern:?}: {why} is not supported")),
+        Ok(c) if c > MAX_COST => Err(format!("pattern {pattern:?} is too complex: too many ways to match one name")),
+        Ok(_) => Ok(()),
+    }
+}
+
+fn unsupported_construct(pattern: &str) -> Option<&'static str> {
+    if pattern.match_indices("(?").any(|(at, _)| !pattern[at + 2..].starts_with(':')) {
+        return Some("an inline flag, lookaround or named group");
+    }
+    UNSUPPORTED.iter().find(|(needle, _)| pattern.contains(needle)).map(|(_, what)| *what)
+}
+
+fn cost(hir: &Hir) -> Result<u64, &'static str> {
+    match hir.kind() {
+        HirKind::Empty | HirKind::Literal(_) | HirKind::Class(_) | HirKind::Look(_) => Ok(1),
+        HirKind::Capture(c) => cost(&c.sub),
+        HirKind::Concat(items) => items.iter().try_fold(1u64, |acc, h| Ok(acc.saturating_mul(cost(h)?))),
+        HirKind::Alternation(items) => items.iter().try_fold(0u64, |acc, h| Ok(acc.saturating_add(cost(h)?))),
+        HirKind::Repetition(r) => match r.max {
+            None if matches!(r.sub.kind(), HirKind::Literal(_) | HirKind::Class(_)) => Ok(NAME_LEN),
+            None => Err("a repeated group (`(…)*`, `(…)+`)"),
+            Some(max) => Ok(cost(&r.sub)?.saturating_add(1).saturating_pow(max)),
+        },
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn err(pattern: &str) -> String {
+        validate_pattern(pattern).unwrap_err()
+    }
+
+    #[test]
+    fn accepts_typical_file_name_patterns() {
+        for pattern in [
+            r"^(architecture|ARCHITECTURE)(\.(md|rst|txt))?$",
+            r"(main|workflow|ci|release|build|config)\.ya?ml$",
+            r"^[a-z]+\.d\.ts$",
+            r"^\.?eslintrc(\.(js|cjs|json|ya?ml))?$",
+            r"^.*\.config\.[cm]?[jt]s$",
+            r"^.*-(test|spec)\..*$",
+            r"^[0-9]{4}-[0-9]{2}\.log$",
+        ] {
+            assert!(validate_pattern(pattern).is_ok(), "{pattern}: {:?}", validate_pattern(pattern));
+        }
+    }
+
+    #[test]
+    fn rejects_patterns_that_backtrack_catastrophically() {
+        assert!(err(r"(a+)+$").contains("repeated group"));
+        assert!(err(r"(?:a*)*").contains("repeated group"));
+        assert!(err(r"^(\w|\w\w)*!$").contains("repeated group"));
+        assert!(err(r"^(a|aa)+$").contains("repeated group"));
+        assert!(err(r"^.*.*.*x$").contains("too complex"));
+        assert!(err(r"^(a?){30}a{30}$").contains("too complex"));
+        assert!(err(&format!("^{}b$", "(a|aa)".repeat(20))).contains("too complex"));
+        assert!(err(r"x{0,40}").contains("too complex"));
+    }
+
+    #[test]
+    fn rejects_constructs_javascript_reads_differently() {
+        assert!(err(r"(?i)readme").contains("not supported"));
+        assert!(err(r"(?P<n>a)").contains("not supported"));
+        assert!(err(r"\Areadme").contains("not supported"));
+        assert!(err(r"readme\z").contains("not supported"));
+        assert!(err(r"\p{L}").contains("not supported"));
+        assert!(err(r"[[:alpha:]]").contains("not supported"));
+        assert!(err(r"[a-z&&[^x]]").contains("not supported"));
+    }
+
+    #[test]
+    fn rejects_invalid_and_oversized_patterns() {
+        assert!(err("(").contains("invalid pattern"));
+        assert!(err(&"a".repeat(MAX_PATTERN_LEN + 1)).contains("too long"));
+    }
+}

crates/ide-host/src/plugins/icon_settings.rs

@@ -0,0 +1,185 @@
+use super::icon_extensions::Extensions;
+use serde::{Deserialize, Serialize};
+
+const MAX_SECTIONS: usize = 16;
+const MAX_ITEMS: usize = 32;
+const MAX_TEXT_LEN: usize = 255;
+const MAX_HINT_LEN: usize = 512;
+const MAX_COLUMNS: u8 = 4;
+
+#[derive(Clone, Copy, PartialEq, Eq, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) enum SettingOption {
+    HideFiles,
+    HideFolders,
+    HideUiIcons,
+    HidePsiIcons,
+    HollowFolders,
+    Groups,
+    Choice,
+    Accent,
+    Monochrome,
+    Saturation,
+    Opacity,
+    IconSize,
+    RowHeight,
+}
+
+#[derive(Deserialize, Serialize)]
+#[serde(untagged)]
+pub(super) enum SettingDefault {
+    Number(u8),
+    Color(String),
+}
+
+#[derive(Deserialize, Serialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub(super) struct SettingItem {
+    option: SettingOption,
+    #[serde(default)]
+    label: Option<String>,
+    #[serde(default)]
+    hint: Option<String>,
+    #[serde(default)]
+    invert: bool,
+    #[serde(default)]
+    choice: Option<String>,
+    #[serde(default)]
+    columns: Option<u8>,
+    #[serde(default)]
+    default: Option<SettingDefault>,
+}
+
+#[derive(Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub(super) struct SettingsSection {
+    title: String,
+    items: Vec<SettingItem>,
+}
+
+#[derive(Serialize)]
+struct ChoiceSummary<'a> {
+    id: &'a str,
+    name: &'a str,
+    default: &'a str,
+    options: Vec<OptionSummary<'a>>,
+}
+
+#[derive(Serialize)]
+struct OptionSummary<'a> {
+    id: &'a str,
+    name: &'a str,
+}
+
+fn check_text(text: &str, max: usize, what: &str) -> Result<(), String> {
+    if text.trim().is_empty() || text.len() > max {
+        return Err(format!("settings: {what} must have 1 to {max} characters"));
+    }
+    Ok(())
+}
+
+fn range(option: SettingOption) -> Option<(u8, u8)> {
+    match option {
+        SettingOption::Saturation => Some((0, 20)),
+        SettingOption::Opacity => Some((10, 100)),
+        SettingOption::IconSize => Some((12, 32)),
+        SettingOption::RowHeight => Some((16, 48)),
+        _ => None,
+    }
+}
+
+fn is_color(text: &str) -> bool {
+    text.len() == 7 && text.starts_with('#') && text[1..].chars().all(|c| c.is_ascii_hexdigit())
+}
+
+fn is_flag(option: SettingOption) -> bool {
+    matches!(
+        option,
+        SettingOption::HideFiles
+            | SettingOption::HideFolders
+            | SettingOption::HideUiIcons
+            | SettingOption::HidePsiIcons
+            | SettingOption::HollowFolders
+    )
+}
+
+impl SettingItem {
+    fn validate(&self, ext: &Extensions) -> Result<(), String> {
+        let named = !matches!(self.option, SettingOption::Groups | SettingOption::Choice);
+        match &self.label {
+            Some(label) => check_text(label, MAX_TEXT_LEN, "label")?,
+            None if named => return Err("settings: label is required".into()),
+            None => {}
+        }
+        if let Some(hint) = &self.hint {
+            check_text(hint, MAX_HINT_LEN, "hint")?;
+        }
+        if self.invert && !is_flag(self.option) {
+            return Err("settings: invert is only for on/off options".into());
+        }
+        if self.columns.is_some_and(|c| c == 0 || c > MAX_COLUMNS)
+            || (self.columns.is_some() && self.option != SettingOption::Groups)
+        {
+            return Err(format!("settings: columns are 1 to {MAX_COLUMNS}, for groups only"));
+        }
+        match (self.option, &self.choice) {
+            (SettingOption::Choice, Some(id)) if !ext.choices.iter().any(|c| &c.id == id) => {
+                return Err(format!("settings: unknown choice {id:?}"));
+            }
+            (SettingOption::Choice, None) => return Err("settings: choice items name their choice".into()),
+            (SettingOption::Choice, Some(_)) | (_, None) => {}
+            (_, Some(_)) => return Err("settings: only choice items name a choice".into()),
+        }
+        if self.option == SettingOption::Accent && !ext.accent {
+            return Err("settings: the accent option needs \"accent\": true".into());
+        }
+        self.validate_default()
+    }
+
+    fn validate_default(&self) -> Result<(), String> {
+        let colored = matches!(self.option, SettingOption::Accent | SettingOption::Monochrome);
+        match (range(self.option), &self.default) {
+            (Some((min, max)), Some(SettingDefault::Number(n))) if (min..=max).contains(n) => Ok(()),
+            (Some((min, max)), _) => Err(format!("settings: a default from {min} to {max} is required")),
+            (None, Some(SettingDefault::Color(c))) if colored && is_color(c) => Ok(()),
+            (None, _) if colored => Err("settings: a #rrggbb default is required".into()),
+            (None, None) => Ok(()),
+            (None, Some(_)) => Err("settings: this option takes no default".into()),
+        }
+    }
+}
+
+pub(super) fn validate(sections: &[SettingsSection], ext: &Extensions) -> Result<(), String> {
+    if sections.len() > MAX_SECTIONS {
+        return Err(format!("settings: more than {MAX_SECTIONS} sections"));
+    }
+    for section in sections {
+        check_text(&section.title, MAX_TEXT_LEN, "title")?;
+        if section.items.len() > MAX_ITEMS {
+            return Err(format!("settings: more than {MAX_ITEMS} items in {:?}", section.title));
+        }
+        for item in &section.items {
+            item.validate(ext)?;
+        }
+    }
+    Ok(())
+}
+
+pub(super) fn summary(sections: &[SettingsSection], ext: &Extensions) -> serde_json::Value {
+    let choices: Vec<ChoiceSummary> = ext
+        .choices
+        .iter()
+        .map(|c| ChoiceSummary {
+            id: &c.id,
+            name: &c.name,
+            default: &c.default,
+            options: c.options.iter().map(|o| OptionSummary { id: &o.id, name: &o.name }).collect(),
+        })
+        .collect();
+    serde_json::json!({
+        "groups": ext.groups,
+        "choices": choices,
+        "accent": ext.accent,
+        "settings": sections,
+    })
+}

crates/ide-host/src/plugins/icons.rs

@@ -0,0 +1,844 @@
+//! The `iconThemes` extension point: file and folder icons.
+//!
+//! ```toml
+//! [[contributes.iconThemes]]
+//! id = "material"
+//! label = "Material Icons"
+//! path = "icons/theme.json"
+//! ```
+//!
+//! `theme.json` (paths relative to the package):
+//!
+//! ```json
+//! {
+//!   "iconDefinitions": { "rust": "icons/rust.svg", "folder-src": "icons/folder-src.svg" },
+//!   "file": "file", "folder": "folder", "folderExpanded": "folder-open",
+//!   "fileExtensions": { "rs": "rust" },
+//!   "fileNames": { "cargo.toml": "cargo" },
+//!   "folderNames": { "src": "folder-src" }
+//! }
+//! ```
+//!
+//! Every SVG is sanitised here (allow-listed elements and attributes, no
+//! scripts, event handlers, external references or entities) and stored as an
+//! asset; the client fetches the mapping and the icons only when the theme is
+//! selected, so installed icon themes cost nothing at start-up.
+
+use super::icon_extensions::{Choice, DARK_SUFFIX, Extensions, Group, IconDefinition, Pattern, check_icon_id};
+use super::icon_settings::{self, SettingsSection};
+use ide_extension::{Package, UiDecl, check_relative, decode, validate_item_id};
+use serde::Deserialize;
+use std::collections::{BTreeMap, BTreeSet};
+use std::path::PathBuf;
+
+pub const POINT_ID: &str = "iconThemes";
+const MAX_ICONS: usize = 5000;
+const MAX_SVG: usize = 64 << 10;
+const MAX_MAPPINGS: usize = 20_000;
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct Decl {
+    id: String,
+    label: String,
+    path: PathBuf,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+struct ThemeFile {
+    icon_definitions: BTreeMap<String, IconDefinition>,
+    #[serde(default)]
+    file: Option<String>,
+    #[serde(default)]
+    folder: Option<String>,
+    #[serde(default)]
+    folder_expanded: Option<String>,
+    #[serde(default)]
+    folder_open: Option<String>,
+    #[serde(default)]
+    file_extensions: BTreeMap<String, String>,
+    #[serde(default)]
+    file_names: BTreeMap<String, String>,
+    #[serde(default)]
+    folder_names: BTreeMap<String, String>,
+    #[serde(default)]
+    patterns: Vec<Pattern>,
+    #[serde(default)]
+    overrides: BTreeMap<String, String>,
+    #[serde(default)]
+    groups: Vec<Group>,
+    #[serde(default)]
+    choices: Vec<Choice>,
+    #[serde(default)]
+    accent: bool,
+    #[serde(default)]
+    settings: Vec<SettingsSection>,
+}
+
+/// Asset id of a theme's mapping (JSON).
+pub fn map_asset(theme: &str) -> String {
+    format!("iconTheme/{theme}/map")
+}
+
+pub fn settings_asset(theme: &str) -> String {
+    format!("iconTheme/{theme}/settings")
+}
+
+/// Asset id prefix of a theme's SVGs (`…/svg/<icon id>`).
+pub fn svg_prefix(theme: &str) -> String {
+    format!("iconTheme/{theme}/svg/")
+}
+
+/// An SVG icon of the package, size-checked and sanitised.
+pub(super) fn read_icon(pkg: &Package, path: &std::path::Path) -> Result<String, String> {
+    check_relative(path, "icon")?;
+    let svg = pkg.read_text(path)?;
+    if svg.len() > MAX_SVG {
+        return Err(format!("{}: larger than {} KiB", path.display(), MAX_SVG >> 10));
+    }
+    sanitize_svg(&svg).map_err(|e| format!("{}: {e}", path.display()))
+}
+
+pub(super) fn icon_theme(pkg: &Package, decl: toml::Value) -> Result<UiDecl, String> {
+    let d: Decl = decode(POINT_ID, decl)?;
+    validate_item_id(&d.id, "icon theme id")?;
+    if d.label.trim().is_empty() {
+        return Err(format!("icon theme {:?} has an empty label", d.id));
+    }
+    let src = pkg.read_text(&d.path)?;
+    let mut theme: ThemeFile = serde_json::from_str(&src).map_err(|e| format!("{}: {e}", d.path.display()))?;
+    let extensions = Extensions {
+        patterns: std::mem::take(&mut theme.patterns),
+        overrides: std::mem::take(&mut theme.overrides),
+        groups: std::mem::take(&mut theme.groups),
+        choices: std::mem::take(&mut theme.choices),
+        accent: theme.accent,
+    };
+    let at = |what: &str| format!("{} ({what})", d.path.display());
+    if theme.icon_definitions.len() > MAX_ICONS {
+        return Err(format!("{}: more than {MAX_ICONS} icons", d.path.display()));
+    }
+    let mappings =
+        theme.file_extensions.len() + theme.file_names.len() + theme.folder_names.len() + extensions.mappings();
+    if mappings > MAX_MAPPINGS {
+        return Err(format!("{}: more than {MAX_MAPPINGS} mappings", d.path.display()));
+    }
+    let defined: BTreeSet<&str> = theme.icon_definitions.keys().map(String::as_str).collect();
+    let check_ref = |icon: &str, what: &str| -> Result<(), String> {
+        if defined.contains(icon) { Ok(()) } else { Err(format!("{}: unknown icon {icon:?}", at(what))) }
+    };
+    for icon in theme.icon_definitions.keys() {
+        check_icon_id(icon)?;
+    }
+    extensions.validate(&check_ref)?;
+    icon_settings::validate(&theme.settings, &extensions).map_err(|e| format!("{}: {e}", d.path.display()))?;
+    for (what, icon) in [
+        ("file", &theme.file),
+        ("folder", &theme.folder),
+        ("folderExpanded", &theme.folder_expanded),
+        ("folderOpen", &theme.folder_open),
+    ] {
+        if let Some(icon) = icon {
+            check_ref(icon, what)?;
+        }
+    }
+    // Extensions may be written with their dot (`.rs`); names keep theirs (`.github`, `.gitignore`).
+    let lower = |map: &BTreeMap<String, String>, what: &str| -> Result<BTreeMap<String, String>, String> {
+        let mut out = BTreeMap::new();
+        for (k, icon) in map {
+            check_ref(icon, what)?;
+            let key = k.trim();
+            let key = if what == "fileExtensions" { key.trim_start_matches('.') } else { key }.to_lowercase();
+            if key.is_empty() || key.contains(['/', '\\']) {
+                return Err(format!("{}: invalid key {k:?}", at(what)));
+            }
+            out.insert(key, icon.clone());
+        }
+        Ok(out)
+    };
+    let file_extensions = lower(&theme.file_extensions, "fileExtensions")?;
+    let file_names = lower(&theme.file_names, "fileNames")?;
+    let folder_names = lower(&theme.folder_names, "folderNames")?;
+
+    let mut assets = Vec::with_capacity(theme.icon_definitions.len() + 1);
+    let mut files = vec![d.path.clone()];
+    for (icon, def) in &theme.icon_definitions {
+        let dark = def.dark().map(|path| (path, DARK_SUFFIX));
+        for (path, suffix) in std::iter::once((def.light(), "")).chain(dark) {
+            let clean = read_icon(pkg, path)?;
+            assets.push((format!("{}{icon}{suffix}", svg_prefix(&d.id)), clean));
+            files.push(path.clone());
+        }
+    }
+    let map = serde_json::json!({
+        "file": theme.file,
+        "folder": theme.folder,
+        "folderExpanded": theme.folder_expanded,
+        "folderOpen": theme.folder_open,
+        "fileExtensions": file_extensions,
+        "fileNames": file_names,
+        "folderNames": folder_names,
+        "patterns": extensions.patterns,
+        "overrides": extensions.overrides,
+        "groups": extensions.groups,
+        "choices": extensions.choices,
+        "accent": extensions.accent,
+    });
+    if !theme.settings.is_empty() {
+        assets.push((settings_asset(&d.id), icon_settings::summary(&theme.settings, &extensions).to_string()));
+    }
+    assets.push((map_asset(&d.id), map.to_string()));
+    let json = serde_json::json!({ "id": d.id, "label": d.label, "icons": theme.icon_definitions.len() });
+    let mut out = UiDecl::new(d.id.clone(), d.label, json);
+    out.files = files;
+    out.assets = assets;
+    Ok(out)
+}
+
+// ---------------------------------------------------------------------------
+// SVG sanitiser
+
+const ELEMENTS: &[&str] = &[
+    "svg",
+    "g",
+    "path",
+    "circle",
+    "ellipse",
+    "line",
+    "polyline",
+    "polygon",
+    "rect",
+    "defs",
+    "lineargradient",
+    "radialgradient",
+    "stop",
+    "clippath",
+    "mask",
+    "use",
+    "symbol",
+    "pattern",
+    "text",
+    "tspan",
+    "filter",
+    "fegaussianblur",
+    "feoffset",
+    "feblend",
+    "fecolormatrix",
+    "feflood",
+    "fecomposite",
+    "femerge",
+    "femergenode",
+    "fedropshadow",
+];
+
+/// Dropped with their content: harmless metadata.
+const STRIPPED: &[&str] = &["title", "desc", "metadata"];
+
+const ATTRIBUTES: &[&str] = &[
+    "id",
+    "class",
+    "viewbox",
+    "width",
+    "height",
+    "x",
+    "y",
+    "x1",
+    "y1",
+    "x2",
+    "y2",
+    "cx",
+    "cy",
+    "r",
+    "rx",
+    "ry",
+    "fx",
+    "fy",
+    "d",
+    "points",
+    "transform",
+    "fill",
+    "fill-opacity",
+    "fill-rule",
+    "clip-rule",
+    "clip-path",
+    "mask",
+    "stroke",
+    "stroke-width",
+    "stroke-linecap",
+    "stroke-linejoin",
+    "stroke-miterlimit",
+    "stroke-dasharray",
+    "stroke-dashoffset",
+    "stroke-opacity",
+    "opacity",
+    "offset",
+    "stop-color",
+    "stop-opacity",
+    "gradientunits",
+    "gradienttransform",
+    "spreadmethod",
+    "patternunits",
+    "patterncontentunits",
+    "patterntransform",
+    "clippathunits",
+    "maskunits",
+    "maskcontentunits",
+    "preserveaspectratio",
+    "style",
+    "href",
+    "xlink:href",
+    "xmlns",
+    "xmlns:xlink",
+    "version",
+    "font-family",
+    "font-size",
+    "font-weight",
+    "text-anchor",
+    "dominant-baseline",
+    "letter-spacing",
+    "display",
+    "visibility",
+    "color",
+    "filter",
+    "in",
+    "in2",
+    "result",
+    "stddeviation",
+    "dx",
+    "dy",
+    "mode",
+    "operator",
+    "values",
+    "type",
+    "flood-color",
+    "flood-opacity",
+    "k1",
+    "k2",
+    "k3",
+    "k4",
+    "filterunits",
+    "primitiveunits",
+    "vector-effect",
+    "shape-rendering",
+    "isolation",
+    "mix-blend-mode",
+];
+
+/// Parses `src` and re-serialises the allow-listed subset. Fails on anything
+/// that could execute, fetch or escape (scripts, `foreignObject`, event
+/// handlers, external `href`s, `url()` to anything but a local fragment,
+/// DTDs, entities, CDATA).
+pub fn sanitize_svg(src: &str) -> Result<String, String> {
+    let mut out = String::with_capacity(src.len());
+    let mut stack: Vec<String> = Vec::new();
+    // Depth inside a stripped element (its content is skipped).
+    let mut skip_depth = 0usize;
+    let mut seen_root = false;
+    let mut rest = src;
+    while !rest.is_empty() {
+        let Some(lt) = rest.find('<') else {
+            if skip_depth == 0 && !stack.is_empty() {
+                out.push_str(&text(rest)?);
+            } else if !rest.trim().is_empty() && stack.is_empty() {
+                return Err("text outside the <svg> element".into());
+            }
+            break;
+        };
+        if lt > 0 {
+            let t = &rest[..lt];
+            if skip_depth == 0 && !stack.is_empty() {
+                out.push_str(&text(t)?);
+            } else if stack.is_empty() && !t.trim().is_empty() {
+                return Err("text outside the <svg> element".into());
+            }
+        }
+        rest = &rest[lt..];
+        if let Some(after) = rest.strip_prefix("<!--") {
+            let end = after.find("-->").ok_or("unterminated comment")?;
+            rest = &after[end + 3..];
+            continue;
+        }
+        if rest.starts_with("<?") {
+            let end = rest.find("?>").ok_or("unterminated processing instruction")?;
+            rest = &rest[end + 2..];
+            continue;
+        }
+        if rest.starts_with("<!") {
+            return Err("DTDs, entities and CDATA are not allowed".into());
+        }
+        if let Some(after) = rest.strip_prefix("</") {
+            let end = after.find('>').ok_or("unterminated closing tag")?;
+            let name = after[..end].trim().to_ascii_lowercase();
+            rest = &after[end + 1..];
+            let open = stack.pop().ok_or_else(|| format!("unexpected </{name}>"))?;
+            if open != name {
+                return Err(format!("</{name}> does not close <{open}>"));
+            }
+            if skip_depth > 0 {
+                skip_depth -= 1;
+            } else {
+                out.push_str(&format!("</{name}>"));
+            }
+            continue;
+        }
+        // Start tag.
+        let end = tag_end(rest).ok_or("unterminated tag")?;
+        let inner = &rest[1..end];
+        rest = &rest[end + 1..];
+        let self_closing = inner.trim_end().ends_with('/');
+        let inner = inner.trim_end().trim_end_matches('/');
+        let name_end = inner.find(|c: char| c.is_whitespace()).unwrap_or(inner.len());
+        let raw_name = &inner[..name_end];
+        let name = raw_name.to_ascii_lowercase();
+        if name.is_empty() {
+            return Err("empty tag".into());
+        }
+        if stack.is_empty() {
+            if seen_root || name != "svg" {
+                return Err("the file must contain exactly one <svg> element".into());
+            }
+            seen_root = true;
+        }
+        if !self_closing {
+            stack.push(name.clone());
+        }
+        if skip_depth > 0 {
+            if !self_closing {
+                skip_depth += 1;
+            }
+            continue;
+        }
+        if STRIPPED.contains(&name.as_str()) || name.contains(':') {
+            // Editor metadata (sodipodi:namedview) or descriptive text.
+            if !self_closing {
+                skip_depth = 1;
+            }
+            continue;
+        }
+        if !ELEMENTS.contains(&name.as_str()) {
+            return Err(format!("<{raw_name}> is not allowed"));
+        }
+        out.push('<');
+        out.push_str(raw_name);
+        for (attr, value) in attributes(&inner[name_end..])? {
+            let key = attr.to_ascii_lowercase();
+            if key.starts_with("on") {
+                return Err(format!("event handler {attr} is not allowed"));
+            }
+            if key.contains(':') && !matches!(key.as_str(), "xlink:href" | "xmlns:xlink") {
+                continue; // inkscape:label, sodipodi:docname, …
+            }
+            if !ATTRIBUTES.contains(&key.as_str()) && !key.starts_with("data-") && !key.starts_with("aria-") {
+                return Err(format!("attribute {attr} is not allowed"));
+            }
+            check_value(&key, &value).map_err(|e| format!("{attr}: {e}"))?;
+            out.push(' ');
+            out.push_str(&attr);
+            out.push_str("=\"");
+            out.push_str(&escape(&value));
+            out.push('"');
+        }
+        out.push_str(if self_closing { "/>" } else { ">" });
+    }
+    if !stack.is_empty() {
+        return Err(format!("<{}> is not closed", stack.last().map(String::as_str).unwrap_or("?")));
+    }
+    if !seen_root {
+        return Err("no <svg> element".into());
+    }
+    Ok(out)
+}
+
+/// Index of the `>` ending the tag at the start of `s`, skipping quoted values.
+fn tag_end(s: &str) -> Option<usize> {
+    let mut quote: Option<char> = None;
+    for (i, c) in s.char_indices().skip(1) {
+        match (quote, c) {
+            (Some(q), c) if c == q => quote = None,
+            (Some(_), _) => {}
+            (None, '"' | '\'') => quote = Some(c),
+            (None, '>') => return Some(i),
+            (None, '<') => return None,
+            _ => {}
+        }
+    }
+    None
+}
+
+fn attributes(s: &str) -> Result<Vec<(String, String)>, String> {
+    let mut out = Vec::new();
+    let mut rest = s.trim_start();
+    while !rest.is_empty() {
+        let eq = rest.find('=').ok_or_else(|| format!("attribute without value near {:?}", clip(rest)))?;
+        let name = rest[..eq].trim();
+        if name.is_empty() || name.contains(|c: char| c.is_whitespace() || c == '"' || c == '\'') {
+            return Err(format!("malformed attribute near {:?}", clip(rest)));
+        }
+        let after = rest[eq + 1..].trim_start();
+        let quote = after.chars().next().filter(|c| *c == '"' || *c == '\'').ok_or("unquoted attribute value")?;
+        let close = after[1..].find(quote).ok_or("unterminated attribute value")?;
+        let value = decode_entities(&after[1..1 + close])?;
+        if out.iter().any(|(n, _): &(String, String)| n.eq_ignore_ascii_case(name)) {
+            return Err(format!("duplicate attribute {name}"));
+        }
+        out.push((name.to_owned(), value));
+        rest = after[close + 2..].trim_start();
+    }
+    Ok(out)
+}
+
+fn check_value(key: &str, value: &str) -> Result<(), String> {
+    let lower = value.to_ascii_lowercase();
+    if matches!(key, "href" | "xlink:href") {
+        return if value.starts_with('#') { Ok(()) } else { Err("only local references (#id) are allowed".into()) };
+    }
+    if key == "xmlns" || key == "xmlns:xlink" {
+        return Ok(());
+    }
+    if lower.contains("javascript:")
+        || lower.contains("expression(")
+        || lower.contains("@import")
+        || value.contains('\\')
+    {
+        return Err("unsafe value".into());
+    }
+    let mut rest = lower.as_str();
+    while let Some(i) = rest.find("url(") {
+        let inner = rest[i + 4..].trim_start().trim_start_matches(['"', '\'']);
+        if !inner.starts_with('#') {
+            return Err("url() may only reference a local fragment".into());
+        }
+        rest = &rest[i + 4..];
+    }
+    Ok(())
+}
+
+fn decode_entities(s: &str) -> Result<String, String> {
+    if !s.contains('&') {
+        return Ok(s.to_owned());
+    }
+    let mut out = String::with_capacity(s.len());
+    let mut rest = s;
+    while let Some(i) = rest.find('&') {
+        out.push_str(&rest[..i]);
+        let semi = rest[i..].find(';').ok_or("unterminated entity")?;
+        let ent = &rest[i + 1..i + semi];
+        let c = match ent {
+            "amp" => '&',
+            "lt" => '<',
+            "gt" => '>',
+            "quot" => '"',
+            "apos" => '\'',
+            _ => {
+                let code = if let Some(hex) = ent.strip_prefix("#x").or_else(|| ent.strip_prefix("#X")) {
+                    u32::from_str_radix(hex, 16).ok()
+                } else if let Some(dec) = ent.strip_prefix('#') {
+                    dec.parse().ok()
+                } else {
+                    None
+                };
+                code.and_then(char::from_u32).ok_or_else(|| format!("entity &{ent}; is not allowed"))?
+            }
+        };
+        out.push(c);
+        rest = &rest[i + semi + 1..];
+    }
+    out.push_str(rest);
+    Ok(out)
+}
+
+fn text(t: &str) -> Result<String, String> {
+    Ok(escape(&decode_entities(t)?))
+}
+
+fn escape(s: &str) -> String {
+    s.replace('&', "&amp;").replace('<', "&lt;").replace('>', "&gt;").replace('"', "&quot;")
+}
+
+fn clip(s: &str) -> &str {
+    let mut end = s.len().min(24);
+    while !s.is_char_boundary(end) {
+        end -= 1;
+    }
+    &s[..end]
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn keeps_ordinary_icons() {
+        let src = r##"<?xml version="1.0"?>
+<!-- Material icon -->
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:inkscape="x" viewBox="0 0 24 24" inkscape:version="1">
+  <title>rust</title>
+  <defs><linearGradient id="g"><stop offset="0" stop-color="#fff"/></linearGradient></defs>
+  <path fill="url(#g)" d="M1 2h3 &amp; 4" style="opacity:.5"/>
+  <use href="#g"/>
+</svg>"##;
+        let out = sanitize_svg(src).unwrap();
+        assert!(out.starts_with("<svg xmlns="), "{out}");
+        assert!(!out.contains("title") && !out.contains("inkscape") && !out.contains("<!--"));
+        assert!(out.contains(r#"fill="url(#g)""#));
+        assert!(out.contains(r#"d="M1 2h3 &amp; 4""#));
+        assert!(out.ends_with("</svg>"));
+    }
+
+    #[test]
+    fn rejects_active_content() {
+        let bad = [
+            r##"<svg><script>alert(1)</script></svg>"##,
+            r##"<svg onload="alert(1)"></svg>"##,
+            r##"<svg><foreignObject/></svg>"##,
+            r##"<svg><use href="https://evil/x.svg#a"/></svg>"##,
+            r##"<svg><use xlink:href="data:image/svg+xml,..."/></svg>"##,
+            r##"<svg><rect style="fill:url(https://evil)"/></svg>"##,
+            r##"<svg><rect fill="url( 'http://x' )"/></svg>"##,
+            r##"<!DOCTYPE svg [<!ENTITY x "y">]><svg/>"##,
+            r##"<svg><![CDATA[x]]></svg>"##,
+            r##"<svg><a href="#x"/></svg>"##,
+            r##"<svg><rect width="&xx;"/></svg>"##,
+            r##"<svg><rect width=10/></svg>"##,
+            r##"<svg><g></svg>"##,
+            r##"<svg/><svg/>"##,
+            r##"<g/>"##,
+            r##"hello"##,
+            r##"<svg><rect style="behavior:url(#x);x:expression(1)"/></svg>"##,
+        ];
+        for src in bad {
+            assert!(sanitize_svg(src).is_err(), "accepted: {src}");
+        }
+    }
+
+    #[test]
+    fn theme_files_validate_and_produce_assets() {
+        let tmp = tempfile::tempdir().unwrap();
+        let dir = tmp.path();
+        std::fs::create_dir_all(dir.join("icons")).unwrap();
+        std::fs::write(dir.join("icons/rust.svg"), r#"<svg viewBox="0 0 16 16"><path d="M0 0h16v16z"/></svg>"#)
+            .unwrap();
+        std::fs::write(dir.join("icons/file.svg"), r#"<svg viewBox="0 0 16 16"><rect width="16" height="16"/></svg>"#)
+            .unwrap();
+        std::fs::write(
+            dir.join("theme.json"),
+            r#"{"iconDefinitions":{"rust":"icons/rust.svg","file":"icons/file.svg"},"file":"file",
+                "fileExtensions":{".RS":"rust"},"fileNames":{"Cargo.toml":"rust",".gitignore":"file"},
+                "folderNames":{".GitHub":"file","src":"rust"}}"#,
+        )
+        .unwrap();
+        let manifest = ide_extension::Manifest::parse(
+            "id = \"p\"\nname = \"P\"\nversion = \"1.0.0\"\nengines.openidea = \"^1.0\"",
+        )
+        .unwrap();
+        let pkg = Package::new(manifest, dir.to_path_buf());
+        let decl = |path: &str| {
+            let mut t = toml::Table::new();
+            t.insert("id".into(), "m".into());
+            t.insert("label".into(), "M".into());
+            t.insert("path".into(), path.into());
+            toml::Value::Table(t)
+        };
+        let d = icon_theme(&pkg, decl("theme.json")).unwrap();
+        assert_eq!(d.json["icons"], 2);
+        assert_eq!(d.files.len(), 3);
+        let map: serde_json::Value =
+            serde_json::from_str(&d.assets.iter().find(|(k, _)| *k == map_asset("m")).unwrap().1).unwrap();
+        assert_eq!(map["fileExtensions"]["rs"], "rust");
+        assert_eq!(map["fileNames"]["cargo.toml"], "rust");
+        // Names keep their leading dot (only extensions drop it).
+        assert_eq!(map["fileNames"][".gitignore"], "file");
+        assert_eq!(map["folderNames"][".github"], "file");
+        assert_eq!(map["folderNames"]["src"], "rust");
+        assert!(map["folderNames"].get("github").is_none());
+        assert!(d.assets.iter().any(|(k, _)| *k == format!("{}rust", svg_prefix("m"))));
+
+        std::fs::write(dir.join("bad.json"), r#"{"iconDefinitions":{},"fileExtensions":{"rs":"nope"}}"#).unwrap();
+        assert!(icon_theme(&pkg, decl("bad.json")).unwrap_err().contains("unknown icon"));
+        std::fs::write(dir.join("icons/evil.svg"), r#"<svg><script/></svg>"#).unwrap();
+        std::fs::write(dir.join("evil.json"), r#"{"iconDefinitions":{"e":"icons/evil.svg"}}"#).unwrap();
+        assert!(icon_theme(&pkg, decl("evil.json")).unwrap_err().contains("evil.svg"));
+        assert!(icon_theme(&pkg, decl("../x.json")).is_err());
+    }
+
+    const SVG: &str = r#"<svg viewBox="0 0 16 16"><path d="M0 0h16v16z"/></svg>"#;
+
+    fn theme_package(theme: &str) -> (tempfile::TempDir, Package) {
+        let tmp = tempfile::tempdir().unwrap();
+        let dir = tmp.path();
+        std::fs::create_dir_all(dir.join("icons")).unwrap();
+        for icon in ["file", "folder", "folder-src", "folder-src-open", "rust", "rust-dark", "tests", "arrow"] {
+            std::fs::write(dir.join(format!("icons/{icon}.svg")), SVG).unwrap();
+        }
+        std::fs::write(dir.join("theme.json"), theme).unwrap();
+        let manifest = ide_extension::Manifest::parse(
+            "id = \"p\"\nname = \"P\"\nversion = \"1.0.0\"\nengines.openidea = \"^1.0\"",
+        )
+        .unwrap();
+        let pkg = Package::new(manifest, dir.to_path_buf());
+        (tmp, pkg)
+    }
+
+    fn load(theme: &str) -> Result<UiDecl, String> {
+        let (_tmp, pkg) = theme_package(theme);
+        let mut t = toml::Table::new();
+        t.insert("id".into(), "m".into());
+        t.insert("label".into(), "M".into());
+        t.insert("path".into(), "theme.json".into());
+        icon_theme(&pkg, toml::Value::Table(t))
+    }
+
+    fn with(extra: &str) -> String {
+        format!(
+            r#"{{"iconDefinitions":{{"file":"icons/file.svg","folder":"icons/folder.svg",
+                "folder-src":"icons/folder-src.svg","folder-src-open":"icons/folder-src-open.svg",
+                "rust":{{"light":"icons/rust.svg","dark":"icons/rust-dark.svg"}},
+                "tests":"icons/tests.svg","arrow":"icons/arrow.svg"}},
+                "file":"file","folder":"folder"{extra}}}"#
+        )
+    }
+
+    const EXTENSIONS: &str = r#","patterns":[
+        {"pattern":"^.*\\.rs$","icon":"rust","ignoreCase":true},
+        {"pattern":"/tests?/","icon":"tests","path":true,"group":"tests"},
+        {"pattern":"^src$","icon":"folder-src","target":"folder","openIcon":"folder-src-open"}],
+        "overrides":{"chevron-right":"arrow","symbol-class":"rust"},
+        "groups":[{"id":"tests","name":"Tests","enabled":false}],
+        "choices":[{"id":"arrows","name":"Arrows","default":"plain","options":[
+            {"id":"plain","name":"Default"},{"id":"material","name":"Material","overrides":{"chevron-down":"arrow"}}]}],
+        "accent":true,"folderOpen":"folder-src-open""#;
+
+    fn map_of(d: &UiDecl) -> serde_json::Value {
+        serde_json::from_str(&d.assets.iter().find(|(k, _)| *k == map_asset("m")).unwrap().1).unwrap()
+    }
+
+    #[test]
+    fn theme_extensions_reach_the_mapping() {
+        let d = load(&with(EXTENSIONS)).unwrap();
+        let map = map_of(&d);
+        assert_eq!(
+            map["patterns"],
+            serde_json::json!([
+                {"pattern":"^.*\\.rs$","icon":"rust","target":"file","path":false,"ignoreCase":true,"group":null,"openIcon":null},
+                {"pattern":"/tests?/","icon":"tests","target":"file","path":true,"ignoreCase":false,"group":"tests","openIcon":null},
+                {"pattern":"^src$","icon":"folder-src","target":"folder","path":false,"ignoreCase":false,"group":null,"openIcon":"folder-src-open"}
+            ])
+        );
+        assert_eq!(map["overrides"], serde_json::json!({"chevron-right":"arrow","symbol-class":"rust"}));
+        assert_eq!(map["groups"], serde_json::json!([{"id":"tests","name":"Tests","enabled":false}]));
+        assert_eq!(map["choices"][0]["default"], "plain");
+        assert_eq!(map["choices"][0]["options"][1]["overrides"], serde_json::json!({"chevron-down":"arrow"}));
+        assert_eq!(map["choices"][0]["options"][0]["overrides"], serde_json::json!({}));
+        assert_eq!(map["accent"], true);
+        assert_eq!(map["folderOpen"], "folder-src-open");
+        assert_eq!(d.json["icons"], 7);
+        assert!(d.assets.iter().any(|(k, _)| *k == format!("{}rust", svg_prefix("m"))));
+        assert!(d.assets.iter().any(|(k, _)| *k == format!("{}rust_dark", svg_prefix("m"))));
+        assert!(d.files.iter().any(|f| f.ends_with("icons/rust-dark.svg")));
+    }
+
+    #[test]
+    fn themes_without_extensions_keep_their_mapping() {
+        let map = map_of(&load(&with("")).unwrap());
+        assert_eq!(map["patterns"], serde_json::json!([]));
+        assert_eq!(map["overrides"], serde_json::json!({}));
+        assert_eq!(map["groups"], serde_json::json!([]));
+        assert_eq!(map["choices"], serde_json::json!([]));
+        assert_eq!(map["accent"], false);
+    }
+
+    #[test]
+    fn theme_extensions_are_validated() {
+        let cases = [
+            (r#","patterns":[{"pattern":"x","icon":"nope"}]"#, "unknown icon"),
+            (r#","patterns":[{"pattern":"(a+)+$","icon":"rust"}]"#, "repeated group"),
+            (r#","patterns":[{"pattern":"(","icon":"rust"}]"#, "invalid pattern"),
+            (r#","patterns":[{"pattern":"x","icon":"rust","group":"nope"}]"#, "unknown group"),
+            (r#","patterns":[{"pattern":"x","icon":"rust","openIcon":"tests"}]"#, "openIcon"),
+            (r#","patterns":[{"pattern":"x","icon":"folder","target":"folder","openIcon":"nope"}]"#, "unknown icon"),
+            (r#","patterns":[{"pattern":"x","icon":"rust","priority":1}]"#, "unknown field"),
+            (r#","overrides":{"chevron-right":"nope"}"#, "unknown icon"),
+            (r#","folderOpen":"nope""#, "unknown icon"),
+            (r#","overrides":{"Chevron":"rust"}"#, "invalid overridden icon"),
+            (r#","groups":[{"id":"a","name":" "}]"#, "name"),
+            (r#","groups":[{"id":"a","name":"A"},{"id":"a","name":"B"}]"#, "duplicate"),
+            (r#","choices":[{"id":"c","name":"C","default":"x","options":[{"id":"y","name":"Y"}]}]"#, "default"),
+            (r#","choices":[{"id":"c","name":"C","default":"y","options":[]}]"#, "options"),
+            (
+                r#","choices":[{"id":"c","name":"C","default":"y","options":[{"id":"y","name":"Y","overrides":{"a":"nope"}}]}]"#,
+                "unknown icon",
+            ),
+        ];
+        for (extra, needle) in cases {
+            let err = load(&with(extra)).err().unwrap_or_else(|| panic!("accepted: {extra}"));
+            assert!(err.contains(needle), "{extra}: {err}");
+        }
+        let dark_id = r#"{"iconDefinitions":{"x_dark":"icons/rust.svg"}}"#;
+        assert!(load(dark_id).unwrap_err().contains("_dark"));
+    }
+
+    const SETTINGS: &str = r##","settings":[
+        {"title":"Toggle","items":[
+            {"option":"hideFiles","label":"Enable file icons","hint":"Files","invert":true},
+            {"option":"hollowFolders","label":"Hollow"}]},
+        {"title":"Packs","items":[{"option":"groups","columns":2}]},
+        {"title":"Other","items":[
+            {"option":"choice","choice":"arrows"},
+            {"option":"accent","label":"Accent","default":"#009688"},
+            {"option":"saturation","label":"Saturation","default":10}]}]"##;
+
+    fn settings_of(d: &UiDecl) -> Option<serde_json::Value> {
+        d.assets.iter().find(|(k, _)| *k == settings_asset("m")).map(|(_, v)| serde_json::from_str(v).unwrap())
+    }
+
+    #[test]
+    fn theme_settings_get_their_own_asset() {
+        let d = load(&with(&format!("{EXTENSIONS}{SETTINGS}"))).unwrap();
+        let s = settings_of(&d).unwrap();
+        assert_eq!(s["accent"], true);
+        assert_eq!(s["groups"], serde_json::json!([{"id":"tests","name":"Tests","enabled":false}]));
+        assert_eq!(
+            s["choices"],
+            serde_json::json!([{"id":"arrows","name":"Arrows","default":"plain","options":[
+                {"id":"plain","name":"Default"},{"id":"material","name":"Material"}]}])
+        );
+        assert_eq!(s["settings"][0]["title"], "Toggle");
+        assert_eq!(
+            s["settings"][0]["items"][0],
+            serde_json::json!({"option":"hideFiles","label":"Enable file icons","hint":"Files","invert":true,
+                "choice":null,"columns":null,"default":null})
+        );
+        assert_eq!(s["settings"][2]["items"][1]["default"], "#009688");
+        assert_eq!(s["settings"][2]["items"][2]["default"], 10);
+        assert!(settings_of(&load(&with(EXTENSIONS)).unwrap()).is_none());
+    }
+
+    #[test]
+    fn theme_settings_are_validated() {
+        let section = |items: &str| with(&format!(r#"{EXTENSIONS},"settings":[{{"title":"T","items":[{items}]}}]"#));
+        let cases = [
+            (section(r#"{"option":"nope","label":"X"}"#), "unknown variant"),
+            (section(r#"{"option":"hideFiles"}"#), "label"),
+            (section(r#"{"option":"hideFiles","label":" "}"#), "label"),
+            (section(r#"{"option":"choice","choice":"nope"}"#), "unknown choice"),
+            (section(r#"{"option":"choice"}"#), "choice"),
+            (section(r#"{"option":"groups","columns":9}"#), "columns"),
+            (section(r#"{"option":"saturation","label":"S"}"#), "default"),
+            (section(r#"{"option":"saturation","label":"S","default":50}"#), "default"),
+            (section(r##"{"option":"opacity","label":"O","default":"#000000"}"##), "default"),
+            (section(r#"{"option":"monochrome","label":"M","default":"red"}"#), "default"),
+            (section(r#"{"option":"saturation","label":"S","default":5,"invert":true}"#), "invert"),
+            (section(r#"{"option":"hideFiles","label":"F","extra":1}"#), "unknown field"),
+            (with(&format!(r#"{EXTENSIONS},"settings":[{{"title":"","items":[]}}]"#)), "title"),
+            (
+                with(r##","settings":[{"title":"T","items":[{"option":"accent","label":"A","default":"#000000"}]}]"##),
+                "accent",
+            ),
+        ];
+        for (theme, needle) in cases {
+            let err = load(&theme).err().unwrap_or_else(|| panic!("accepted: {theme}"));
+            assert!(err.contains(needle), "{theme}: {err}");
+        }
+    }
+}

crates/ide-host/src/plugins/install.rs

@@ -0,0 +1,288 @@
+//! Copying a package into the plugins directory without ever leaving the
+//! plugin missing. Installed plugins are versioned:
+//! `<plugins>/<id>/<version>/` plus an `active` pointer file (and `previous`,
+//! the version to roll back to). A new version is written to a staging
+//! directory, renamed into place, and only then made active by replacing the
+//! pointer; a swap interrupted by a crash is undone on the next start
+//! ([`recover`]). Older installs used `<plugins>/<id>/` directly; they are
+//! moved into the versioned layout on their next update.
+
+use std::io;
+use std::path::{Path, PathBuf};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+/// Top-level files copied with a package besides those its declarations reference.
+pub const LICENSE_FILES: &[&str] =
+    &["LICENSE", "LICENSE.md", "LICENSE.txt", "NOTICE", "NOTICE.md", "NOTICE.txt", "COPYING", "README.md"];
+/// Written into an installed package: the package hash the grant ledger compares.
+pub const HASH_FILE: &str = ".package-hash";
+
+const STAGING: &str = ".staging-";
+const OLD: &str = ".old-";
+/// `<root>/active`: the version in use.
+pub const ACTIVE_FILE: &str = "active";
+/// `<root>/previous`: the version an update replaced (for rollback).
+pub const PREVIOUS_FILE: &str = "previous";
+
+fn nonce() -> String {
+    let n = SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_nanos()).unwrap_or_default();
+    format!("{n:x}-{}", std::process::id())
+}
+
+/// Copies `files` (plus manifest and licence files) from `src` into `target`
+/// atomically, recording `hash`.
+pub fn install_package(src: &Path, target: &Path, files: &[PathBuf], hash: &str) -> io::Result<()> {
+    let parent = target.parent().ok_or_else(|| io::Error::other("plugin target has no parent"))?;
+    let name = target.file_name().and_then(|n| n.to_str()).ok_or_else(|| io::Error::other("bad target"))?;
+    std::fs::create_dir_all(parent)?;
+    let staging = parent.join(format!("{STAGING}{name}-{}", nonce()));
+    let result = (|| {
+        std::fs::create_dir_all(&staging)?;
+        std::fs::copy(src.join(ide_extension::MANIFEST_FILE), staging.join(ide_extension::MANIFEST_FILE))?;
+        for file in files {
+            let to = staging.join(file);
+            if let Some(dir) = to.parent() {
+                std::fs::create_dir_all(dir)?;
+            }
+            std::fs::copy(src.join(file), to)?;
+        }
+        for lic in LICENSE_FILES {
+            if src.join(lic).is_file() {
+                std::fs::copy(src.join(lic), staging.join(lic))?;
+            }
+        }
+        std::fs::write(staging.join(HASH_FILE), hash)?;
+        swap(&staging, target, |from, to| std::fs::rename(from, to))
+    })();
+    if result.is_err() {
+        let _ = std::fs::remove_dir_all(&staging);
+    }
+    result
+}
+
+/// A version as a directory name (semver: `[0-9A-Za-z.+-]`).
+fn version_dir(version: &str) -> io::Result<&str> {
+    let ok = !version.is_empty()
+        && version.len() <= 64
+        && !version.starts_with('.')
+        && version.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '+' | '-'));
+    if ok { Ok(version) } else { Err(io::Error::other(format!("version {version:?} cannot name a directory"))) }
+}
+
+fn read_pointer(root: &Path, name: &str) -> Option<String> {
+    let v = std::fs::read_to_string(root.join(name)).ok()?;
+    let v = v.trim();
+    (!v.is_empty() && version_dir(v).is_ok()).then(|| v.to_owned())
+}
+
+/// Replaces the pointer file `name` atomically.
+fn write_pointer(root: &Path, name: &str, version: &str) -> io::Result<()> {
+    let tmp = root.join(format!(".{name}.tmp"));
+    std::fs::write(&tmp, version)?;
+    std::fs::rename(&tmp, root.join(name))
+}
+
+/// The directory of a plugin's active version under its `root`
+/// (`<plugins>/<id>`): `<root>/<active>`, or `root` itself in the flat layout.
+pub fn active_dir(root: &Path) -> Option<PathBuf> {
+    if let Some(v) = read_pointer(root, ACTIVE_FILE) {
+        let dir = root.join(v);
+        return dir.join(ide_extension::MANIFEST_FILE).is_file().then_some(dir);
+    }
+    root.join(ide_extension::MANIFEST_FILE).is_file().then(|| root.to_path_buf())
+}
+
+/// The version an update replaced, if it is still there.
+pub fn previous_version(root: &Path) -> Option<String> {
+    read_pointer(root, PREVIOUS_FILE).filter(|v| root.join(v).join(ide_extension::MANIFEST_FILE).is_file())
+}
+
+/// Moves a flat install (`<root>/plugin.toml`) to `<root>/<version>/`.
+fn migrate_flat(root: &Path, version_of: impl Fn(&Path) -> Option<String>) -> io::Result<()> {
+    if read_pointer(root, ACTIVE_FILE).is_some() || !root.join(ide_extension::MANIFEST_FILE).is_file() {
+        return Ok(());
+    }
+    let version = version_of(root).unwrap_or_else(|| "0.0.0".into());
+    let version = version_dir(&version).map(str::to_owned).unwrap_or_else(|_| "0.0.0".into());
+    let parent = root.parent().unwrap_or(Path::new("."));
+    let name = root.file_name().and_then(|n| n.to_str()).ok_or_else(|| io::Error::other("bad plugin directory"))?;
+    // `.old-<name>-…` is restored by `recover` if this is interrupted.
+    let old = parent.join(format!("{OLD}{name}-{}", nonce()));
+    std::fs::rename(root, &old)?;
+    std::fs::create_dir_all(root)?;
+    std::fs::rename(&old, root.join(&version))?;
+    write_pointer(root, ACTIVE_FILE, &version)
+}
+
+/// Installs `files` of `src` as `<root>/<version>` and makes it the active
+/// version. Returns the version it replaced (now `previous`).
+pub fn install_version(
+    src: &Path,
+    root: &Path,
+    version: &str,
+    files: &[PathBuf],
+    hash: &str,
+    version_of: impl Fn(&Path) -> Option<String>,
+) -> io::Result<Option<String>> {
+    let version = version_dir(version)?;
+    std::fs::create_dir_all(root)?;
+    migrate_flat(root, version_of)?;
+    install_package(src, &root.join(version), files, hash)?;
+    let previous = read_pointer(root, ACTIVE_FILE).filter(|v| v != version);
+    if let Some(p) = &previous {
+        write_pointer(root, PREVIOUS_FILE, p)?;
+    }
+    write_pointer(root, ACTIVE_FILE, version)?;
+    Ok(previous)
+}
+
+/// Makes `version` active again (rollback). The replaced version stays until [`prune`].
+pub fn activate_version(root: &Path, version: &str) -> io::Result<()> {
+    let version = version_dir(version)?;
+    if !root.join(version).join(ide_extension::MANIFEST_FILE).is_file() {
+        return Err(io::Error::other(format!("version {version} is not installed")));
+    }
+    let _ = std::fs::remove_file(root.join(PREVIOUS_FILE));
+    write_pointer(root, ACTIVE_FILE, version)
+}
+
+/// Removes versions other than the active and the previous one.
+pub fn prune(root: &Path) {
+    let keep: Vec<String> = [ACTIVE_FILE, PREVIOUS_FILE].iter().filter_map(|f| read_pointer(root, f)).collect();
+    if keep.is_empty() {
+        return;
+    }
+    let Ok(entries) = std::fs::read_dir(root) else { return };
+    for e in entries.flatten() {
+        let path = e.path();
+        let name = e.file_name().to_string_lossy().into_owned();
+        if path.is_dir() && !keep.contains(&name) {
+            let _ = std::fs::remove_dir_all(&path);
+        }
+    }
+}
+
+/// Moves `staging` to `target`, keeping the old `target` until the new one is in place.
+fn swap(staging: &Path, target: &Path, rename: impl Fn(&Path, &Path) -> io::Result<()>) -> io::Result<()> {
+    if !target.exists() {
+        return rename(staging, target);
+    }
+    let parent = target.parent().unwrap_or(Path::new("."));
+    let name = target.file_name().and_then(|n| n.to_str()).unwrap_or("plugin");
+    let old = parent.join(format!("{OLD}{name}-{}", nonce()));
+    rename(target, &old)?;
+    if let Err(e) = rename(staging, target) {
+        // Put the previous version back.
+        rename(&old, target)?;
+        return Err(e);
+    }
+    if let Err(e) = std::fs::remove_dir_all(&old) {
+        tracing::warn!("removing the previous version {}: {e}", old.display());
+    }
+    Ok(())
+}
+
+/// Undoes interrupted installs in `dir`: restores `.old-<name>-*` when
+/// `<name>` is missing, and removes leftover staging and old directories.
+pub fn recover(dir: &Path) {
+    let Ok(entries) = std::fs::read_dir(dir) else { return };
+    for entry in entries.flatten() {
+        let path = entry.path();
+        // Inside a versioned plugin: staging and old versions of a version swap.
+        if path.is_dir() && read_pointer(&path, ACTIVE_FILE).is_some() {
+            recover(&path);
+            continue;
+        }
+        let Some(file) = path.file_name().and_then(|n| n.to_str()).map(str::to_owned) else { continue };
+        if file.starts_with(STAGING) {
+            let _ = std::fs::remove_dir_all(&path);
+        } else if let Some(rest) = file.strip_prefix(OLD) {
+            // `<name>-<nonce>-<pid>`: the name is everything before the last two parts.
+            let parts: Vec<&str> = rest.rsplitn(3, '-').collect();
+            let name = parts.get(2).copied().unwrap_or_default();
+            let target = dir.join(name);
+            // A layout migration interrupted after creating the new root: it is still empty.
+            if !name.is_empty() && target.is_dir() && active_dir(&target).is_none() {
+                let _ = std::fs::remove_dir_all(&target);
+            }
+            if !name.is_empty() && !target.exists() {
+                tracing::warn!("restoring {} after an interrupted install", target.display());
+                let _ = std::fs::rename(&path, &target);
+            } else {
+                let _ = std::fs::remove_dir_all(&path);
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn failed_swap_keeps_the_old_version() {
+        let tmp = tempfile::tempdir().unwrap();
+        let target = tmp.path().join("p");
+        let staging = tmp.path().join(".staging-p-1");
+        std::fs::create_dir_all(&target).unwrap();
+        std::fs::write(target.join("v"), "1").unwrap();
+        std::fs::create_dir_all(&staging).unwrap();
+        std::fs::write(staging.join("v"), "2").unwrap();
+        let calls = std::cell::Cell::new(0);
+        let err = swap(&staging, &target, |a, b| {
+            calls.set(calls.get() + 1);
+            if calls.get() == 2 { Err(io::Error::other("disk full")) } else { std::fs::rename(a, b) }
+        });
+        assert!(err.is_err());
+        assert_eq!(std::fs::read_to_string(target.join("v")).unwrap(), "1");
+        swap(&staging, &target, |a, b| std::fs::rename(a, b)).unwrap();
+        assert_eq!(std::fs::read_to_string(target.join("v")).unwrap(), "2");
+        assert_eq!(std::fs::read_dir(tmp.path()).unwrap().count(), 1, "old version removed");
+    }
+
+    #[test]
+    fn versions_are_installed_side_by_side_and_rolled_back() {
+        let tmp = tempfile::tempdir().unwrap();
+        let src = tmp.path().join("src");
+        std::fs::create_dir_all(&src).unwrap();
+        let root = tmp.path().join("plugins/acme.tools");
+        let version_of = |_: &Path| Some("0.9.0".to_owned());
+        // A flat install from before versioning.
+        std::fs::create_dir_all(&root).unwrap();
+        std::fs::write(root.join(ide_extension::MANIFEST_FILE), "v0.9").unwrap();
+        assert_eq!(active_dir(&root), Some(root.clone()));
+
+        std::fs::write(src.join(ide_extension::MANIFEST_FILE), "v1").unwrap();
+        assert_eq!(install_version(&src, &root, "1.0.0", &[], "h1", version_of).unwrap().as_deref(), Some("0.9.0"));
+        assert_eq!(active_dir(&root), Some(root.join("1.0.0")));
+        std::fs::write(src.join(ide_extension::MANIFEST_FILE), "v2").unwrap();
+        assert_eq!(install_version(&src, &root, "2.0.0", &[], "h2", version_of).unwrap().as_deref(), Some("1.0.0"));
+        assert_eq!(previous_version(&root).as_deref(), Some("1.0.0"));
+        prune(&root);
+        assert!(!root.join("0.9.0").exists(), "older than previous: pruned");
+
+        activate_version(&root, "1.0.0").unwrap();
+        assert_eq!(
+            std::fs::read_to_string(active_dir(&root).unwrap().join(ide_extension::MANIFEST_FILE)).unwrap(),
+            "v1"
+        );
+        assert_eq!(previous_version(&root), None);
+        assert!(install_version(&src, &root, "../x", &[], "h", version_of).is_err());
+    }
+
+    #[test]
+    fn recover_restores_an_interrupted_swap() {
+        let tmp = tempfile::tempdir().unwrap();
+        std::fs::create_dir_all(tmp.path().join(".old-acme.tools-1a2b-77")).unwrap();
+        std::fs::write(tmp.path().join(".old-acme.tools-1a2b-77/v"), "1").unwrap();
+        std::fs::create_dir_all(tmp.path().join(".staging-acme.tools-1a2c-77")).unwrap();
+        std::fs::create_dir_all(tmp.path().join("x")).unwrap();
+        std::fs::create_dir_all(tmp.path().join(".old-x-1-2")).unwrap();
+        recover(tmp.path());
+        assert_eq!(std::fs::read_to_string(tmp.path().join("acme.tools/v")).unwrap(), "1");
+        let mut names: Vec<_> =
+            std::fs::read_dir(tmp.path()).unwrap().flatten().map(|e| e.file_name().into_string().unwrap()).collect();
+        names.sort();
+        assert_eq!(names, ["acme.tools", "x"]);
+    }
+}

crates/ide-host/src/plugins/intellij.rs

@@ -0,0 +1,874 @@
+//! IntelliJ theme plugins, read for import as OpenIDEA theme plugins: a
+//! Marketplace download (a `.jar`, or a `.zip` holding the plugin's
+//! `lib/*.jar`), an installed plugin's folder or a loose `.theme.json`; and the
+//! theme plugins of the JetBrains IDEs on this machine, with the theme each IDE
+//! is set to (`options/laf.xml`).
+//!
+//! Nothing is converted here: the UI maps IntelliJ keys onto design tokens
+//! (`src/features/plugins/intellijTheme.ts`, shared with `pnpm
+//! theme:import-intellij`) and [`super::PluginHost::stage_package`] writes the
+//! result for the install page, which validates it like any package.
+
+use ide_core::{IdeError, IdeResult, IpcPath};
+use quick_xml::{Reader, XmlVersion, events::Event};
+use serde::{Deserialize, Serialize};
+use specta::Type;
+use std::ffi::OsString;
+use std::io::{Cursor, Read, Seek};
+use std::path::{Path, PathBuf};
+
+/// A descriptor, theme or editor scheme larger than this is not one.
+const MAX_FILE: u64 = 4 << 20;
+/// A plugin jar read into memory from a Marketplace zip.
+const MAX_JAR: u64 = 64 << 20;
+/// Jars of one plugin looked into.
+const MAX_JARS: usize = 64;
+/// All the jars read into memory from one Marketplace zip.
+const MAX_NESTED: u64 = 256 << 20;
+/// Descriptors read for one plugin: `plugin.xml` and those it includes.
+const MAX_DESCRIPTORS: usize = 64;
+const PLUGIN_XML: &str = "META-INF/plugin.xml";
+
+/// A theme plugin's themes, as read from its files.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct IntellijThemeSource {
+    /// The plugin's `<name>`, or the theme's for a loose file.
+    pub name: String,
+    pub plugin_id: Option<String>,
+    pub version: Option<String>,
+    pub vendor: Option<String>,
+    pub themes: Vec<IntellijThemeFile>,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct IntellijThemeFile {
+    /// The `themeProvider` id (what `laf.xml` names), or the file name without `.theme.json`.
+    pub id: String,
+    /// The `.theme.json`, comments removed.
+    pub theme: String,
+    /// The editor scheme (`.icls` XML) its `editorScheme` names, when the plugin has it.
+    pub editor_scheme: Option<String>,
+}
+
+/// A theme of a plugin installed in a JetBrains IDE.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct InstalledIntellijTheme {
+    /// The IDE and its version: `IntelliJ IDEA 2025.2`.
+    pub ide: String,
+    /// The plugin's name.
+    pub plugin: String,
+    /// What to import: the plugin's folder or jar.
+    pub path: IpcPath,
+    pub theme_id: String,
+    pub theme_name: String,
+    pub dark: bool,
+    /// The IDE is set to this theme.
+    pub active: bool,
+}
+
+/// Reads the themes of an IntelliJ theme plugin (a `.jar`, a Marketplace
+/// `.zip`, an installed plugin's folder) or of a `.theme.json`.
+pub fn read_source(path: &Path) -> IdeResult<IntellijThemeSource> {
+    read(path).map_err(IdeError::invalid)
+}
+
+/// The theme plugins of the JetBrains IDEs (and Android Studio) of this user,
+/// the themes their IDEs are set to first.
+pub fn installed_themes() -> Vec<InstalledIntellijTheme> {
+    let Some(home) = dirs::home_dir() else { return Vec::new() };
+    let layout = if cfg!(target_os = "macos") {
+        Layout::Mac
+    } else if cfg!(windows) {
+        Layout::Windows
+    } else {
+        Layout::Xdg
+    };
+    find_installed(&ide_dirs(layout, &home, |key| std::env::var_os(key)))
+}
+
+fn read(path: &Path) -> Result<IntellijThemeSource, String> {
+    if path.extension().is_some_and(|e| e.eq_ignore_ascii_case("json")) {
+        return loose_theme(path);
+    }
+    let mut jars = plugin_jars(path)?;
+    let plugin = descriptor(&mut jars)?;
+    let shown = || path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
+    if plugin.themes.is_empty() {
+        return Err(format!("{} is not a theme plugin: its plugin.xml declares no themeProvider", shown()));
+    }
+    let mut themes = Vec::new();
+    let mut problem = None;
+    for (id, theme_path) in &plugin.themes {
+        match plugin_theme(&mut jars, id, theme_path) {
+            Ok(theme) => themes.push(theme),
+            Err(e) => problem = problem.or(Some(e)),
+        }
+    }
+    if themes.is_empty() {
+        return Err(problem.unwrap_or_else(|| format!("{} has no readable theme", shown())));
+    }
+    Ok(IntellijThemeSource {
+        name: plugin.name.unwrap_or_else(shown),
+        plugin_id: plugin.id,
+        version: plugin.version,
+        vendor: plugin.vendor,
+        themes,
+    })
+}
+
+fn plugin_theme(jars: &mut [Jar], id: &str, path: &str) -> Result<IntellijThemeFile, String> {
+    let bytes = find(jars, entry_name(path), MAX_FILE)?.ok_or_else(|| format!("{path} is missing from the plugin"))?;
+    let (theme, fields) = theme_json(&bytes).map_err(|e| format!("{path}: {e}"))?;
+    let editor_scheme = match string_field(&fields, "editorScheme") {
+        Some(scheme) => find(jars, entry_name(scheme), MAX_FILE)?.map(|b| text(&b)),
+        None => None,
+    };
+    Ok(IntellijThemeFile { id: id.to_owned(), theme, editor_scheme })
+}
+
+/// A `.theme.json` with the editor scheme beside it (its `editorScheme` names a path in the plugin's jar).
+fn loose_theme(path: &Path) -> Result<IntellijThemeSource, String> {
+    let (theme, fields) = theme_json(&read_file(path)?).map_err(|e| format!("{}: {e}", path.display()))?;
+    // Any JSON object parses: an IntelliJ theme has UI colours or an editor scheme.
+    let scheme_ref = string_field(&fields, "editorScheme");
+    if !fields.get("ui").is_some_and(serde_json::Value::is_object) && scheme_ref.is_none() {
+        return Err(format!("{} is not an IntelliJ theme: it has no \"ui\" or \"editorScheme\"", path.display()));
+    }
+    let editor_scheme = scheme_ref
+        .and_then(|p| Path::new(p).file_name().map(|n| path.with_file_name(n)))
+        .filter(|p| p.is_file())
+        .map(|p| read_file(&p).map(|b| text(&b)))
+        .transpose()?;
+    let file = path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
+    let id = file.strip_suffix(".theme.json").or_else(|| file.strip_suffix(".json")).unwrap_or(&file).to_owned();
+    Ok(IntellijThemeSource {
+        name: string_field(&fields, "name").map_or_else(|| id.clone(), str::to_owned),
+        plugin_id: None,
+        version: None,
+        vendor: string_field(&fields, "author").map(str::to_owned),
+        themes: vec![IntellijThemeFile { id, theme, editor_scheme }],
+    })
+}
+
+type JsonObject = serde_json::Map<String, serde_json::Value>;
+
+/// The theme JSON, comments removed, and its fields, if it is an object.
+fn theme_json(bytes: &[u8]) -> Result<(String, JsonObject), String> {
+    let json = super::theme::strip_json_comments(&text(bytes));
+    match serde_json::from_str::<serde_json::Value>(&json) {
+        Ok(serde_json::Value::Object(fields)) => Ok((json, fields)),
+        Ok(_) => Err("not a theme: expected a JSON object".into()),
+        Err(e) => Err(format!("invalid theme JSON: {e}")),
+    }
+}
+
+fn string_field<'a>(fields: &'a JsonObject, key: &str) -> Option<&'a str> {
+    fields.get(key)?.as_str().filter(|s| !s.trim().is_empty())
+}
+
+/// `/themes/x.theme.json` → `themes/x.theme.json`.
+fn entry_name(path: &str) -> &str {
+    path.trim().trim_start_matches('/')
+}
+
+fn text(bytes: &[u8]) -> String {
+    let bytes = bytes.strip_prefix(b"\xEF\xBB\xBF").unwrap_or(bytes);
+    String::from_utf8_lossy(bytes).into_owned()
+}
+
+fn read_file(path: &Path) -> Result<Vec<u8>, String> {
+    let shown = |e: std::io::Error| format!("{}: {e}", path.display());
+    let file = std::fs::File::open(path).map_err(shown)?;
+    let mut buf = Vec::new();
+    file.take(MAX_FILE + 1).read_to_end(&mut buf).map_err(shown)?;
+    if buf.len() as u64 > MAX_FILE {
+        return Err(format!("{} is too large for a theme", path.display()));
+    }
+    Ok(buf)
+}
+
+trait ReadSeek: Read + Seek {}
+impl<T: Read + Seek> ReadSeek for T {}
+type Jar = zip::ZipArchive<Box<dyn ReadSeek>>;
+
+fn open_jar(path: &Path) -> Result<Jar, String> {
+    let file = std::fs::File::open(path).map_err(|e| format!("{}: {e}", path.display()))?;
+    let reader: Box<dyn ReadSeek> = Box::new(std::io::BufReader::new(file));
+    zip::ZipArchive::new(reader).map_err(|e| format!("{} is not a jar or zip file ({e})", path.display()))
+}
+
+/// The jars of the plugin at `path`: a jar, a Marketplace zip (`<plugin>/lib/*.jar`)
+/// or an installed plugin's folder (`lib/*.jar`).
+fn plugin_jars(path: &Path) -> Result<Vec<Jar>, String> {
+    let not_plugin = || format!("{} is not an IntelliJ plugin: no {PLUGIN_XML} and no lib/*.jar", path.display());
+    if path.is_dir() {
+        let mut found: Vec<PathBuf> = [path.join("lib"), path.join("lib").join("modules")]
+            .iter()
+            .flat_map(|dir| std::fs::read_dir(dir).into_iter().flatten().flatten())
+            .map(|e| e.path())
+            .filter(|p| p.is_file() && is_jar(p))
+            .collect();
+        found.sort();
+        let jars: Vec<Jar> = found.iter().take(MAX_JARS).filter_map(|p| open_jar(p).ok()).collect();
+        return if jars.is_empty() { Err(not_plugin()) } else { Ok(jars) };
+    }
+    let mut archive = open_jar(path)?;
+    if archive.index_for_name(PLUGIN_XML).is_some() {
+        return Ok(vec![archive]);
+    }
+    let jars = nested_jars(&mut archive, MAX_JAR, MAX_NESTED);
+    if jars.is_empty() { Err(not_plugin()) } else { Ok(jars) }
+}
+
+/// The `lib` jars of a Marketplace zip, smallest first (a theme's own jar is small)
+/// while they fit `max_total`; library jars too large or not jars at all are skipped.
+fn nested_jars(archive: &mut Jar, max_jar: u64, max_total: u64) -> Vec<Jar> {
+    let mut nested: Vec<(u64, String)> = entry_names(archive)
+        .into_iter()
+        .filter(|n| is_lib_jar(n))
+        .filter_map(|n| Some((archive.by_name(&n).ok()?.size(), n)))
+        .filter(|(size, _)| *size <= max_jar)
+        .collect();
+    nested.sort();
+    let (mut jars, mut loaded) = (Vec::new(), 0u64);
+    for (size, name) in nested.into_iter().take(MAX_JARS) {
+        if loaded.saturating_add(size) > max_total {
+            break;
+        }
+        let Ok(Some(bytes)) = read_entry(archive, &name, max_jar) else { continue };
+        loaded += size;
+        let reader: Box<dyn ReadSeek> = Box::new(Cursor::new(bytes));
+        if let Ok(jar) = zip::ZipArchive::new(reader) {
+            jars.push(jar);
+        }
+    }
+    jars
+}
+
+fn entry_names(jar: &Jar) -> Vec<String> {
+    jar.file_names().filter_map(Result::ok).map(|n| n.into_owned()).collect()
+}
+
+fn is_jar(path: &Path) -> bool {
+    path.extension().is_some_and(|e| e.eq_ignore_ascii_case("jar"))
+}
+
+/// `lib/x.jar`, `<plugin>/lib/x.jar` or `<plugin>/lib/modules/x.jar` in a Marketplace zip.
+fn is_lib_jar(name: &str) -> bool {
+    let parts: Vec<&str> = name.split('/').collect();
+    let n = parts.len();
+    name.to_ascii_lowercase().ends_with(".jar")
+        && (2..=4).contains(&n)
+        && (parts[n - 2] == "lib" || (n >= 3 && parts[n - 2] == "modules" && parts[n - 3] == "lib"))
+}
+
+fn read_entry(jar: &mut Jar, name: &str, max: u64) -> Result<Option<Vec<u8>>, String> {
+    let Ok(file) = jar.by_name(name) else { return Ok(None) };
+    if file.is_dir() {
+        return Ok(None);
+    }
+    if file.size() > max {
+        return Err(format!("{name} is too large"));
+    }
+    let mut buf = Vec::with_capacity(file.size() as usize);
+    file.take(max.saturating_add(1)).read_to_end(&mut buf).map_err(|e| format!("{name}: {e}"))?;
+    if buf.len() as u64 > max {
+        return Err(format!("{name} is too large"));
+    }
+    Ok(Some(buf))
+}
+
+fn find(jars: &mut [Jar], name: &str, max: u64) -> Result<Option<Vec<u8>>, String> {
+    for jar in jars.iter_mut() {
+        if let Some(bytes) = read_entry(jar, name, max)? {
+            return Ok(Some(bytes));
+        }
+    }
+    Ok(None)
+}
+
+/// What the plugin's descriptors say: `<idea-plugin>`'s `id`, `name`, `version`,
+/// `vendor`, and its `themeProvider`s (id, path in the jar).
+#[derive(Debug, Default, PartialEq)]
+struct Descriptor {
+    id: Option<String>,
+    name: Option<String>,
+    version: Option<String>,
+    vendor: Option<String>,
+    themes: Vec<(String, String)>,
+}
+
+/// Reads `META-INF/plugin.xml` and the descriptors it includes (`<xi:include href>`), in any jar.
+fn descriptor(jars: &mut [Jar]) -> Result<Descriptor, String> {
+    let main = find(jars, PLUGIN_XML, MAX_FILE)
+        .ok()
+        .flatten()
+        .ok_or_else(|| format!("not an IntelliJ plugin: no {PLUGIN_XML}"))?;
+    let mut out = Descriptor::default();
+    let mut includes = Vec::new();
+    parse_descriptor(&text(&main), true, &mut out, &mut includes).map_err(|e| format!("{PLUGIN_XML}: {e}"))?;
+    let mut read = std::collections::HashSet::from([PLUGIN_XML.to_owned()]);
+    while let Some(href) = includes.pop() {
+        let name = include_entry(&href);
+        if read.len() >= MAX_DESCRIPTORS || !read.insert(name.clone()) {
+            continue;
+        }
+        let Ok(Some(bytes)) = find(jars, &name, MAX_FILE) else { continue };
+        let _ = parse_descriptor(&text(&bytes), false, &mut out, &mut includes);
+    }
+    let mut seen = std::collections::HashSet::new();
+    out.themes.retain(|(id, _)| seen.insert(id.clone()));
+    Ok(out)
+}
+
+/// An `<xi:include href>` as a jar entry: `/META-INF/x.xml` from the jar's root, `x.xml` beside plugin.xml.
+fn include_entry(href: &str) -> String {
+    let href = href.trim();
+    href.strip_prefix('/').map_or_else(|| format!("META-INF/{href}"), str::to_owned)
+}
+
+fn parse_descriptor(xml: &str, main: bool, out: &mut Descriptor, includes: &mut Vec<String>) -> Result<(), String> {
+    let mut reader = Reader::from_str(xml);
+    let mut stack: Vec<String> = Vec::new();
+    let mut text = String::new();
+    loop {
+        let event = reader.read_event().map_err(|e| e.to_string())?;
+        match event {
+            Event::Start(ref tag) | Event::Empty(ref tag) => {
+                let name = tag.local_name().as_ref().to_owned();
+                if name == "include" {
+                    let href = tag.attributes().flatten().find(|a| a.key.local_name().as_ref() == "href");
+                    if let Some(href) = href.and_then(|a| a.normalized_value(XmlVersion::Implicit1_0).ok()) {
+                        includes.push(href.into_owned());
+                    }
+                }
+                if name == "themeProvider" {
+                    let (mut id, mut path) = (None, None);
+                    for a in tag.attributes() {
+                        let a = a.map_err(|e| e.to_string())?;
+                        let value = a.normalized_value(XmlVersion::Implicit1_0).map_err(|e| e.to_string())?;
+                        match a.key.local_name().as_ref() {
+                            "id" => id = Some(value.trim().to_owned()),
+                            "path" => path = Some(value.trim().to_owned()),
+                            _ => {}
+                        }
+                    }
+                    if let (Some(id), Some(path)) = (id, path)
+                        && !id.is_empty()
+                        && !path.is_empty()
+                    {
+                        out.themes.push((id, path));
+                    }
+                }
+                if matches!(event, Event::Start(_)) {
+                    stack.push(name);
+                    text.clear();
+                }
+            }
+            Event::Text(t) => text.push_str(&t.xml_content(XmlVersion::Implicit1_0)),
+            Event::CData(t) => text.push_str(t.as_ref()),
+            Event::GeneralRef(r) => {
+                let name = r.as_ref();
+                let escaped = format!("&{name};");
+                text.push_str(&quick_xml::escape::unescape(&escaped).map_err(|e| e.to_string())?);
+            }
+            Event::End(_) => {
+                let name = stack.pop().ok_or("unbalanced element")?;
+                // Direct children of <idea-plugin>.
+                if main && stack.len() == 1 && stack[0] == "idea-plugin" {
+                    let value = text.trim();
+                    let slot = match name.as_str() {
+                        "id" => Some(&mut out.id),
+                        "name" => Some(&mut out.name),
+                        "version" => Some(&mut out.version),
+                        "vendor" => Some(&mut out.vendor),
+                        _ => None,
+                    };
+                    if let Some(slot) = slot
+                        && slot.is_none()
+                        && !value.is_empty()
+                    {
+                        *slot = Some(value.to_owned());
+                    }
+                }
+                text.clear();
+            }
+            Event::Eof => return if stack.is_empty() { Ok(()) } else { Err("unclosed element".into()) },
+            _ => {}
+        }
+    }
+}
+
+/// Where an OS keeps the IDEs' settings and plugins.
+#[derive(Clone, Copy, Debug)]
+enum Layout {
+    /// `~/Library/Application Support/<vendor>/<IDE>`, plugins in its `plugins/`.
+    Mac,
+    /// `%APPDATA%\<vendor>\<IDE>`, plugins in its `plugins\`.
+    Windows,
+    /// `$XDG_CONFIG_HOME/<vendor>/<IDE>`, plugins in `$XDG_DATA_HOME/<vendor>/<IDE>`.
+    Xdg,
+}
+
+#[derive(Debug, PartialEq)]
+struct IdeDir {
+    label: String,
+    product: String,
+    version: (u32, u32),
+    config: PathBuf,
+    plugins: PathBuf,
+}
+
+/// The settings folders of JetBrains IDEs and Android Studio (2020.1 and later), newest first.
+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 {
+        Layout::Mac => {
+            let root = home.join("Library").join("Application Support");
+            (root.clone(), root)
+        }
+        Layout::Windows => {
+            let root = var("APPDATA").unwrap_or_else(|| home.join("AppData").join("Roaming"));
+            (root.clone(), root)
+        }
+        Layout::Xdg => (
+            var("XDG_CONFIG_HOME").unwrap_or_else(|| home.join(".config")),
+            var("XDG_DATA_HOME").unwrap_or_else(|| home.join(".local").join("share")),
+        ),
+    };
+    let mut out = Vec::new();
+    for vendor in ["JetBrains", "Google"] {
+        for entry in std::fs::read_dir(config_root.join(vendor)).into_iter().flatten().flatten() {
+            let name = entry.file_name().to_string_lossy().into_owned();
+            let Some((product, version, shown)) = product_dir(&name) else { continue };
+            let config = entry.path();
+            if !config.is_dir() {
+                continue;
+            }
+            let plugins = match layout {
+                Layout::Xdg => data_root.join(vendor).join(&name),
+                Layout::Mac | Layout::Windows => config.join("plugins"),
+            };
+            out.push(IdeDir {
+                label: format!("{} {shown}", product_label(product)),
+                product: product.to_owned(),
+                version,
+                config,
+                plugins,
+            });
+        }
+    }
+    out.sort_by(|a, b| b.version.cmp(&a.version).then_with(|| a.label.cmp(&b.label)));
+    out
+}
+
+/// `IntelliJIdea2025.2` → (`IntelliJIdea`, (2025, 2), `2025.2`).
+fn product_dir(name: &str) -> Option<(&str, (u32, u32), &str)> {
+    let at = name.find(|c: char| c.is_ascii_digit())?;
+    let (product, version) = name.split_at(at);
+    if product.is_empty() || !product.chars().all(|c| c.is_ascii_alphabetic()) {
+        return None;
+    }
+    let (year, minor) = version.split_once('.')?;
+    let ok = |s: &str| !s.is_empty() && s.len() <= 4 && s.chars().all(|c| c.is_ascii_digit());
+    if year.len() != 4 || !ok(year) || !ok(minor) {
+        return None;
+    }
+    Some((product, (year.parse().ok()?, minor.parse().ok()?), version))
+}
+
+fn product_label(product: &str) -> &str {
+    match product {
+        "IntelliJIdea" => "IntelliJ IDEA",
+        "IdeaIC" => "IntelliJ IDEA Community Edition",
+        "PyCharmCE" => "PyCharm Community Edition",
+        "AndroidStudio" => "Android Studio",
+        "AndroidStudioPreview" => "Android Studio Preview",
+        other => other,
+    }
+}
+
+/// The theme ids `options/laf.xml` selects: the current one, and with "Sync with OS" the preferred light and dark.
+fn active_theme_ids(config: &Path) -> Vec<String> {
+    let Ok(bytes) = read_file(&config.join("options").join("laf.xml")) else { return Vec::new() };
+    let xml = text(&bytes);
+    let mut reader = Reader::from_str(&xml);
+    let (mut ids, mut preferred, mut autodetect) = (Vec::new(), Vec::new(), false);
+    loop {
+        match reader.read_event() {
+            Ok(Event::Start(tag) | Event::Empty(tag)) => {
+                let attr = |key: &str| {
+                    tag.attributes()
+                        .flatten()
+                        .find(|a| a.key.as_ref() == key)
+                        .and_then(|a| a.normalized_value(XmlVersion::Implicit1_0).ok().map(|v| v.trim().to_owned()))
+                };
+                match tag.local_name().as_ref() {
+                    "component" if attr("name").as_deref() == Some("LafManager") => {
+                        autodetect = attr("autodetect").as_deref() == Some("true");
+                    }
+                    "laf" => ids.extend(attr("themeId")),
+                    "preferred-light-laf" | "preferred-dark-laf" => preferred.extend(attr("themeId")),
+                    _ => {}
+                }
+            }
+            Ok(Event::Eof) | Err(_) => break,
+            _ => {}
+        }
+    }
+    if autodetect {
+        ids.extend(preferred);
+    }
+    ids.retain(|id| !id.is_empty());
+    ids
+}
+
+fn find_installed(ides: &[IdeDir]) -> Vec<InstalledIntellijTheme> {
+    let mut out = Vec::new();
+    for ide in ides {
+        let active = active_theme_ids(&ide.config);
+        let mut plugins: Vec<PathBuf> = std::fs::read_dir(&ide.plugins)
+            .into_iter()
+            .flatten()
+            .flatten()
+            .map(|e| e.path())
+            .filter(|p| p.is_dir() || (p.is_file() && is_jar(p)))
+            .collect();
+        plugins.sort();
+        for plugin in plugins {
+            let Ok(mut jars) = plugin_jars(&plugin) else { continue };
+            let Ok(found) = descriptor(&mut jars) else { continue };
+            for (id, path) in &found.themes {
+                let Ok(Some(bytes)) = find(&mut jars, entry_name(path), MAX_FILE) else { continue };
+                let Ok((_, fields)) = theme_json(&bytes) else { continue };
+                let file = || plugin.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
+                out.push(InstalledIntellijTheme {
+                    ide: ide.label.clone(),
+                    plugin: found.name.clone().unwrap_or_else(file),
+                    path: plugin.clone().into(),
+                    theme_id: id.clone(),
+                    theme_name: string_field(&fields, "name").unwrap_or(id).to_owned(),
+                    dark: fields.get("dark").and_then(serde_json::Value::as_bool).unwrap_or(true),
+                    active: active.contains(id),
+                });
+            }
+        }
+    }
+    // Stable: the IDEs' order (newest first) within each group.
+    out.sort_by_key(|t| !t.active);
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::Write;
+
+    const PLUGIN: &str = r#"<idea-plugin>
+  <id>com.example.deepsea</id>
+  <name>Deep Sea &amp; Friends</name>
+  <version>2.3</version>
+  <vendor email="[email protected]">Someone</vendor>
+  <description><![CDATA[<b>Dark</b> themes]]></description>
+  <depends>com.intellij.modules.platform</depends>
+  <extensions defaultExtensionNs="com.intellij">
+    <themeProvider id="deep-sea-id" path="/themes/DeepSea.theme.json"/>
+    <themeProvider id="shallow-id" path="themes/Shallow.theme.json" />
+  </extensions>
+</idea-plugin>"#;
+
+    const DEEP: &str = r##"{
+  // comment
+  "name": "Deep Sea",
+  "dark": true,
+  "editorScheme": "/themes/DeepSea.xml",
+  "ui": { "*": { "background": "#101820" } }
+}"##;
+    const SHALLOW: &str = r#"{ "name": "Shallow", "dark": false, "ui": {} }"#;
+    const SCHEME: &str = r#"<scheme name="Deep Sea" version="142" parent_scheme="Darcula"/>"#;
+
+    fn jar_bytes(entries: &[(&str, &[u8])]) -> Vec<u8> {
+        let mut zip = zip::ZipWriter::new(Cursor::new(Vec::new()));
+        for (name, data) in entries {
+            zip.start_file(*name, zip::write::SimpleFileOptions::default()).unwrap();
+            zip.write_all(data).unwrap();
+        }
+        zip.finish().unwrap().into_inner()
+    }
+
+    fn theme_jar() -> Vec<u8> {
+        jar_bytes(&[
+            ("META-INF/MANIFEST.MF", b"Manifest-Version: 1.0\n"),
+            (PLUGIN_XML, PLUGIN.as_bytes()),
+            ("themes/DeepSea.theme.json", DEEP.as_bytes()),
+            ("themes/DeepSea.xml", SCHEME.as_bytes()),
+            ("themes/Shallow.theme.json", SHALLOW.as_bytes()),
+        ])
+    }
+
+    fn write(path: &Path, bytes: &[u8]) {
+        std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+        std::fs::write(path, bytes).unwrap();
+    }
+
+    fn expected_source() -> IntellijThemeSource {
+        IntellijThemeSource {
+            name: "Deep Sea & Friends".into(),
+            plugin_id: Some("com.example.deepsea".into()),
+            version: Some("2.3".into()),
+            vendor: Some("Someone".into()),
+            themes: vec![
+                IntellijThemeFile {
+                    id: "deep-sea-id".into(),
+                    theme: super::super::theme::strip_json_comments(DEEP),
+                    editor_scheme: Some(SCHEME.into()),
+                },
+                IntellijThemeFile { id: "shallow-id".into(), theme: SHALLOW.into(), editor_scheme: None },
+            ],
+        }
+    }
+
+    #[test]
+    fn reads_a_theme_jar_with_its_editor_scheme() {
+        let tmp = tempfile::tempdir().unwrap();
+        let jar = tmp.path().join("deep-sea.jar");
+        write(&jar, &theme_jar());
+        let source = read_source(&jar).unwrap();
+        assert_eq!(source, expected_source());
+        assert!(!source.themes[0].theme.contains("comment"));
+    }
+
+    #[test]
+    fn reads_a_marketplace_zip_and_an_installed_folder() {
+        let tmp = tempfile::tempdir().unwrap();
+        let other = jar_bytes(&[("META-INF/MANIFEST.MF", b"x"), ("a/B.class", b"\xCA\xFE")]);
+        let zip = tmp.path().join("DeepSea-2.3.zip");
+        write(&zip, &jar_bytes(&[("DeepSea/lib/a-util.jar", &other), ("DeepSea/lib/deep-sea.jar", &theme_jar())]));
+        assert_eq!(read_source(&zip).unwrap(), expected_source());
+
+        let dir = tmp.path().join("plugins").join("DeepSea");
+        write(&dir.join("lib").join("deep-sea.jar"), &theme_jar());
+        write(&dir.join("lib").join("a-util.jar"), &other);
+        assert_eq!(read_source(&dir).unwrap(), expected_source());
+    }
+
+    #[test]
+    fn skips_library_jars_it_cannot_or_need_not_read() {
+        let tmp = tempfile::tempdir().unwrap();
+        // Stored, not deflated: as large in the zip as its content.
+        let mut big = zip::ZipWriter::new(Cursor::new(Vec::new()));
+        let stored = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);
+        big.start_file("lib/Data.class", stored).unwrap();
+        big.write_all(&[b'x'; 8192]).unwrap();
+        let big = big.finish().unwrap().into_inner();
+        let zip = tmp.path().join("DeepSea.zip");
+        write(
+            &zip,
+            &jar_bytes(&[
+                ("DeepSea/lib/a-broken.jar", b"not a jar"),
+                ("DeepSea/lib/b-big.jar", &big),
+                ("DeepSea/lib/deep-sea.jar", &theme_jar()),
+            ]),
+        );
+        assert_eq!(read_source(&zip).unwrap(), expected_source());
+
+        // The broken jar is skipped; a jar over the size limit, or past the total
+        // (smallest first), is not read, while the theme's small jar still is.
+        let mut archive = open_jar(&zip).unwrap();
+        let theme_len = theme_jar().len() as u64;
+        assert_eq!(nested_jars(&mut archive, u64::MAX, u64::MAX).len(), 2);
+        let one = nested_jars(&mut archive, theme_len + 64, u64::MAX);
+        assert_eq!(one.len(), 1);
+        assert!(one[0].index_for_name(PLUGIN_XML).is_some());
+        assert_eq!(nested_jars(&mut archive, u64::MAX, theme_len + 64).len(), 1);
+        assert!(nested_jars(&mut archive, 8, u64::MAX).is_empty());
+    }
+
+    #[test]
+    fn reads_a_loose_theme_json_with_the_scheme_beside_it() {
+        let tmp = tempfile::tempdir().unwrap();
+        let theme = tmp.path().join("DeepSea.theme.json");
+        write(&theme, DEEP.as_bytes());
+        write(&tmp.path().join("DeepSea.xml"), SCHEME.as_bytes());
+        let source = read_source(&theme).unwrap();
+        assert_eq!(source.name, "Deep Sea");
+        assert_eq!(source.themes.len(), 1);
+        assert_eq!(source.themes[0].id, "DeepSea");
+        assert_eq!(source.themes[0].editor_scheme.as_deref(), Some(SCHEME));
+
+        std::fs::remove_file(tmp.path().join("DeepSea.xml")).unwrap();
+        assert_eq!(read_source(&theme).unwrap().themes[0].editor_scheme, None);
+    }
+
+    #[test]
+    fn says_what_is_wrong_with_other_files() {
+        let tmp = tempfile::tempdir().unwrap();
+        let not_zip = tmp.path().join("notes.jar");
+        write(&not_zip, b"hello");
+        assert!(read_source(&not_zip).unwrap_err().message.contains("not a jar or zip"));
+
+        let other_plugin = tmp.path().join("tools.jar");
+        let xml = "<idea-plugin><name>Tools</name><actions/></idea-plugin>";
+        write(&other_plugin, &jar_bytes(&[(PLUGIN_XML, xml.as_bytes())]));
+        assert!(read_source(&other_plugin).unwrap_err().message.contains("not a theme plugin"));
+
+        let package = tmp.path().join("package.zip");
+        write(&package, &jar_bytes(&[("plugin.toml", b"id = \"x\"")]));
+        assert!(read_source(&package).unwrap_err().message.contains("not an IntelliJ plugin"));
+
+        let other = tmp.path().join("package.json");
+        write(&other, br#"{ "name": "app", "version": "1.0.0" }"#);
+        assert!(read_source(&other).unwrap_err().message.contains("is not an IntelliJ theme"));
+
+        let broken = tmp.path().join("broken.theme.json");
+        write(&broken, b"{ \"name\": ");
+        assert!(read_source(&broken).unwrap_err().message.contains("invalid theme JSON"));
+
+        let missing = tmp.path().join("missing.jar");
+        let xml = r#"<idea-plugin><name>M</name><themeProvider id="m" path="/m.theme.json"/></idea-plugin>"#;
+        write(&missing, &jar_bytes(&[(PLUGIN_XML, xml.as_bytes())]));
+        assert!(read_source(&missing).unwrap_err().message.contains("/m.theme.json is missing"));
+    }
+
+    #[test]
+    fn finds_theme_providers_in_included_descriptors() {
+        let tmp = tempfile::tempdir().unwrap();
+        let jar = tmp.path().join("split.jar");
+        let main = r#"<idea-plugin xmlns:xi="http://www.w3.org/2001/XInclude"><name>Split</name>
+            <xi:include href="/META-INF/themes.xml"/></idea-plugin>"#;
+        let part = r#"<idea-plugin xmlns:xi="http://www.w3.org/2001/XInclude"><extensions defaultExtensionNs="com.intellij">
+            <themeProvider id="s" path="/s.theme.json"/></extensions><name>Not this</name>
+            <xi:include href="more.xml"/><xi:include href="/META-INF/themes.xml"/></idea-plugin>"#;
+        let more = r#"<idea-plugin><themeProvider id="m" path="/m.theme.json"/></idea-plugin>"#;
+        let unrelated = r#"<idea-plugin><themeProvider id="x" path="/x.theme.json"/></idea-plugin>"#;
+        write(
+            &jar,
+            &jar_bytes(&[
+                ("META-INF/themes.xml", part.as_bytes()),
+                ("META-INF/more.xml", more.as_bytes()),
+                ("META-INF/unrelated.xml", unrelated.as_bytes()),
+                (PLUGIN_XML, main.as_bytes()),
+                ("s.theme.json", br#"{"name":"S"}"#),
+                ("m.theme.json", br#"{"name":"M"}"#),
+                ("x.theme.json", br#"{"name":"X"}"#),
+            ]),
+        );
+        let source = read_source(&jar).unwrap();
+        assert_eq!(source.name, "Split");
+        // Only what plugin.xml includes (relative or from the root, once each) counts.
+        assert_eq!(source.themes.iter().map(|t| t.id.as_str()).collect::<Vec<_>>(), ["s", "m"]);
+    }
+
+    #[test]
+    fn parses_ide_folder_names() {
+        assert_eq!(product_dir("IntelliJIdea2025.2"), Some(("IntelliJIdea", (2025, 2), "2025.2")));
+        assert_eq!(product_dir("PyCharmCE2023.10"), Some(("PyCharmCE", (2023, 10), "2023.10")));
+        assert_eq!(product_dir("AndroidStudio2024.3"), Some(("AndroidStudio", (2024, 3), "2024.3")));
+        for name in
+            ["Toolbox", "consentOptions", "IntelliJIdea2025", "Idea-2025.1", "2025.1", "Rider25.1", "Go Land2025.1"]
+        {
+            assert_eq!(product_dir(name), None, "{name}");
+        }
+    }
+
+    #[test]
+    fn locates_the_settings_and_plugins_of_each_os() {
+        let tmp = tempfile::tempdir().unwrap();
+        let home = tmp.path();
+        let mk = |p: PathBuf| {
+            std::fs::create_dir_all(&p).unwrap();
+            p
+        };
+        let mac = mk(home.join("Library/Application Support/JetBrains/IntelliJIdea2025.2"));
+        mk(home.join("Library/Application Support/JetBrains/Toolbox"));
+        let dirs = ide_dirs(Layout::Mac, home, |_| None);
+        assert_eq!(dirs.len(), 1);
+        assert_eq!(dirs[0].label, "IntelliJ IDEA 2025.2");
+        assert_eq!((dirs[0].config.clone(), dirs[0].plugins.clone()), (mac.clone(), mac.join("plugins")));
+
+        let appdata = mk(home.join("Roaming"));
+        let win = mk(appdata.join("JetBrains/PyCharm2024.3"));
+        let studio = mk(appdata.join("Google/AndroidStudio2025.1"));
+        let env = |k: &str| (k == "APPDATA").then(|| appdata.clone().into_os_string());
+        let dirs = ide_dirs(Layout::Windows, home, env);
+        assert_eq!(
+            dirs.iter().map(|d| d.label.as_str()).collect::<Vec<_>>(),
+            ["Android Studio 2025.1", "PyCharm 2024.3"]
+        );
+        assert_eq!(dirs[1].plugins, win.join("plugins"));
+        assert_eq!(dirs[0].config, studio);
+
+        let config = mk(home.join(".config/JetBrains/IdeaIC2024.1"));
+        mk(home.join(".config/JetBrains/GoLand2025.2"));
+        let dirs = ide_dirs(Layout::Xdg, home, |_| None);
+        assert_eq!(dirs.iter().map(|d| d.product.as_str()).collect::<Vec<_>>(), ["GoLand", "IdeaIC"]);
+        assert_eq!(dirs[1].label, "IntelliJ IDEA Community Edition 2024.1");
+        assert_eq!(dirs[1].config, config);
+        assert_eq!(dirs[1].plugins, home.join(".local/share/JetBrains/IdeaIC2024.1"));
+
+        let xdg_data = home.join("data");
+        let env = |k: &str| (k == "XDG_DATA_HOME").then(|| xdg_data.clone().into_os_string());
+        assert_eq!(ide_dirs(Layout::Xdg, home, env)[1].plugins, xdg_data.join("JetBrains/IdeaIC2024.1"));
+    }
+
+    #[test]
+    fn reads_the_selected_theme_from_laf_xml() {
+        let tmp = tempfile::tempdir().unwrap();
+        let laf = tmp.path().join("options/laf.xml");
+        write(
+            &laf,
+            br#"<application>
+  <component name="LafManager">
+    <laf class-name="com.intellij.ide.ui.laf.UIThemeBasedLookAndFeelInfo" themeId="deep-sea-id" />
+    <preferred-light-laf themeId="shallow-id" />
+  </component>
+</application>"#,
+        );
+        assert_eq!(active_theme_ids(tmp.path()), ["deep-sea-id"]);
+        let synced = std::fs::read_to_string(&laf)
+            .unwrap()
+            .replace(r#"name="LafManager""#, r#"name="LafManager" autodetect="true""#);
+        write(&laf, synced.as_bytes());
+        assert_eq!(active_theme_ids(tmp.path()), ["deep-sea-id", "shallow-id"]);
+        assert!(active_theme_ids(&tmp.path().join("missing")).is_empty());
+    }
+
+    #[test]
+    fn lists_installed_theme_plugins_the_ides_current_first() {
+        let tmp = tempfile::tempdir().unwrap();
+        let config = tmp.path().join("IntelliJIdea2025.2");
+        let plugins = config.join("plugins");
+        write(&plugins.join("DeepSea/lib/deep-sea.jar"), &theme_jar());
+        write(
+            &plugins.join("Tools/lib/tools.jar"),
+            &jar_bytes(&[(PLUGIN_XML, b"<idea-plugin><name>T</name></idea-plugin>")]),
+        );
+        write(&plugins.join("broken.jar"), b"not a jar");
+        write(
+            &config.join("options/laf.xml"),
+            br#"<application><component name="LafManager"><laf themeId="shallow-id"/></component></application>"#,
+        );
+        let ide = IdeDir {
+            label: "IntelliJ IDEA 2025.2".into(),
+            product: "IntelliJIdea".into(),
+            version: (2025, 2),
+            config: config.clone(),
+            plugins: plugins.clone(),
+        };
+        let found = find_installed(&[ide]);
+        let theme = |id: &str, name: &str, dark: bool, active: bool| InstalledIntellijTheme {
+            ide: "IntelliJ IDEA 2025.2".into(),
+            plugin: "Deep Sea & Friends".into(),
+            path: plugins.join("DeepSea").into(),
+            theme_id: id.into(),
+            theme_name: name.into(),
+            dark,
+            active,
+        };
+        assert_eq!(found, [theme("shallow-id", "Shallow", false, true), theme("deep-sea-id", "Deep Sea", true, false)]);
+        assert!(find_installed(&[]).is_empty());
+    }
+}

crates/ide-host/src/plugins/market.rs

@@ -0,0 +1,463 @@
+//! The marketplace: a static index (`index.json` +
+//! packages, served from any URL or folder) lists publishers and their keys,
+//! plugins, and revocations. The host keeps the last index it read
+//! (`market-index.json`), checks signatures against it, and disables what it
+//! revokes — at start-up and on every refresh (the desktop refreshes daily).
+//! Release builds pin the official publisher to the keys they were built
+//! with, so no index can sign `openidea.*` plugins with another key.
+
+use super::{PackageFile, PluginEvent, PluginHost, PluginSource, PluginStatus, PluginUpdate, install};
+use ide_core::{IdeError, IdeResult};
+use ide_extension::package::{self, Index, IndexEntry, PackageSignature, SIGNATURE_FILE};
+use ide_extension::{MANIFEST_FILE, Manifest};
+use semver::Version;
+use serde::{Deserialize, Serialize};
+use std::path::{Path, PathBuf};
+
+/// The official marketplace: the index the release workflow publishes with
+/// the app, next to the signed packages of the official plugins.
+pub const OFFICIAL_INDEX: &str = "https://github.com/l0ng-ai/openidea/releases/latest/download/plugins-index.json";
+
+/// The publisher of the official plugins.
+pub const OFFICIAL_PUBLISHER: &str = "openidea";
+
+/// The last index read, in the plugins directory.
+pub const INDEX_FILE: &str = "market-index.json";
+const DOWNLOADS: &str = ".downloads";
+const MAX_INDEX: usize = 16 << 20;
+const MAX_PACKAGE: usize = 256 << 20;
+const MAX_STAGED_FILES: usize = 256;
+const MAX_STAGED_BYTES: usize = 16 << 20;
+/// `moved` links followed before giving up (a loop, or a misconfiguration).
+const MAX_MOVES: usize = 3;
+
+/// A marketplace entry with what is installed.
+#[derive(Clone, Debug, Serialize, Deserialize, specta::Type)]
+#[serde(rename_all = "camelCase")]
+pub struct MarketPlugin {
+    #[serde(flatten)]
+    pub entry: IndexEntry,
+    /// Installed version, if any.
+    pub installed: Option<String>,
+    /// Whether this IDE can load `entry` (the newest version it can, else the newest).
+    pub compatible: bool,
+}
+
+impl MarketPlugin {
+    /// A version this IDE can load, newer than the one installed.
+    pub fn is_update(&self) -> bool {
+        let newer = |installed: &String| match (Version::parse(&self.entry.version), Version::parse(installed)) {
+            (Ok(offered), Ok(installed)) => offered > installed,
+            _ => false,
+        };
+        self.compatible && self.installed.as_ref().is_some_and(newer)
+    }
+}
+
+/// The official publisher's keys this IDE was built with
+/// (`OPENIDEA_OFFICIAL_PLUGIN_KEYS`: base64, comma-separated). Development
+/// builds have none: the index decides.
+pub(super) fn built_in_official_keys() -> Vec<String> {
+    let keys = option_env!("OPENIDEA_OFFICIAL_PLUGIN_KEYS").unwrap_or_default();
+    keys.split(',').map(str::trim).filter(|k| !k.is_empty()).map(str::to_owned).collect()
+}
+
+fn pinned(mut index: Index, official_keys: &[String]) -> Index {
+    index.pin_publisher(OFFICIAL_PUBLISHER, "OpenIDEA", official_keys);
+    index
+}
+
+/// Reads `url`: `http(s)://…`, `file://…` or a local path.
+pub fn read_url(url: &str, max: usize) -> Result<Vec<u8>, String> {
+    if url.starts_with("https://") || url.starts_with("http://") {
+        let client = ide_http::client::shared().map_err(|e| e.message)?;
+        let url = url.to_owned();
+        return super::api::net_runtime().block_on(async move {
+            let response = client.get(&url).send().await.map_err(|e| format!("{url}: {e}"))?;
+            if !response.status().is_success() {
+                return Err(format!("{url}: HTTP {}", response.status()));
+            }
+            let bytes = response.bytes().await.map_err(|e| format!("{url}: {e}"))?;
+            if bytes.len() > max {
+                return Err(format!("{url}: larger than {} MiB", max >> 20));
+            }
+            Ok(bytes.to_vec())
+        });
+    }
+    let path = url.strip_prefix("file://").unwrap_or(url);
+    let bytes = std::fs::read(path).map_err(|e| format!("{path}: {e}"))?;
+    if bytes.len() > max {
+        return Err(format!("{path}: larger than {} MiB", max >> 20));
+    }
+    Ok(bytes)
+}
+
+/// The index at `url`, following `moved`, with downloads made absolute against
+/// where it was read from.
+fn read_index(url: &str) -> IdeResult<Index> {
+    let mut url = url.to_owned();
+    for _ in 0..=MAX_MOVES {
+        let bytes = read_url(&url, MAX_INDEX).map_err(IdeError::unavailable)?;
+        let text = String::from_utf8(bytes).map_err(|_| IdeError::invalid("the index is not UTF-8"))?;
+        let mut index = Index::parse(&text).map_err(IdeError::invalid)?;
+        match index.moved.take().filter(|m| !m.trim().is_empty()) {
+            Some(next) => {
+                let next = resolve(&url, &next);
+                if url.starts_with("https://") && !next.starts_with("https://") {
+                    return Err(IdeError::invalid(format!("the marketplace moved to {next}, which isn't https")));
+                }
+                url = next;
+            }
+            None => {
+                for e in &mut index.plugins {
+                    e.download = resolve(&url, &e.download);
+                }
+                return Ok(index);
+            }
+        }
+    }
+    Err(IdeError::unavailable(format!("the marketplace index moved more than {MAX_MOVES} times")))
+}
+
+/// `href` relative to the index at `base`: a URL, or a local path (with the
+/// platform's separators, e.g. `C:\\market\\index.json`).
+pub fn resolve(base: &str, href: &str) -> String {
+    if href.contains("://") || href.starts_with('/') || Path::new(href).is_absolute() {
+        return href.to_owned();
+    }
+    if base.contains("://") {
+        return match base.rfind('/') {
+            Some(i) => format!("{}/{href}", &base[..i]),
+            None => href.to_owned(),
+        };
+    }
+    match Path::new(base).parent() {
+        Some(dir) => dir.join(href).to_string_lossy().into_owned(),
+        None => href.to_owned(),
+    }
+}
+
+impl PluginHost {
+    pub(super) fn load_market_index(dir: &Path, official_keys: &[String]) -> Option<Index> {
+        let text = std::fs::read_to_string(dir.join(INDEX_FILE)).ok()?;
+        let index = Index::parse(&text).map_err(|e| tracing::warn!("{INDEX_FILE}: {e}")).ok()?;
+        Some(pinned(index, official_keys))
+    }
+
+    /// Pins the official publisher to `keys` (base64) instead of the built-in
+    /// ones, from the next index read.
+    pub fn set_official_keys(&self, keys: Vec<String>) {
+        *self.official_keys.write() = keys;
+    }
+
+    /// The marketplace index URL: the user's, else the default (none: no marketplace).
+    pub fn market_url(&self) -> Option<String> {
+        self.state.lock().market_url.clone().or_else(|| self.default_market_url.read().clone())
+    }
+
+    /// The marketplace used while the user has set none.
+    pub fn set_default_market_url(&self, url: Option<String>) {
+        *self.default_market_url.write() = url.filter(|u| !u.trim().is_empty());
+    }
+
+    pub fn set_market_url(&self, url: Option<String>) {
+        self.state.lock().market_url = url.filter(|u| !u.trim().is_empty());
+        self.save_state();
+    }
+
+    /// Reads the index again, keeps it, and applies its revocations. Announces
+    /// updates of installed plugins it hasn't announced yet.
+    pub fn refresh_market(&self) -> IdeResult<Vec<MarketPlugin>> {
+        let url = self.market_url().ok_or_else(|| IdeError::unavailable("no plugin marketplace is configured"))?;
+        let index = read_index(&url)?;
+        if let Ok(json) = serde_json::to_string(&index) {
+            let _ = std::fs::write(self.plugins_dir.join(INDEX_FILE), json);
+        }
+        let newer = index.is_newer().then_some(index.format);
+        *self.market.write() = Some(pinned(index, &self.official_keys.read()));
+        // Trust may have changed: who signed what, what is revoked.
+        let installed: Vec<_> =
+            self.plugins.read().values().filter(|p| p.source == PluginSource::Installed).cloned().collect();
+        for plugin in installed {
+            let publisher = self.verified_publisher(plugin.dir());
+            plugin.meta.lock().publisher = publisher;
+        }
+        self.apply_revocations();
+        if let Some(format) = newer {
+            return Err(IdeError::unavailable(format!(
+                "the marketplace needs a newer OpenIDEA (index format {format}); its revocations still apply"
+            )));
+        }
+        let plugins = self.market_plugins();
+        self.announce_updates(&plugins);
+        Ok(plugins)
+    }
+
+    /// Tells the windows about updates once per set of versions: a later
+    /// refresh offering the same ones says nothing.
+    fn announce_updates(&self, plugins: &[MarketPlugin]) {
+        let updates: Vec<PluginUpdate> = plugins
+            .iter()
+            .filter(|p| p.is_update())
+            .map(|p| PluginUpdate {
+                id: p.entry.id.clone(),
+                name: p.entry.name.clone(),
+                version: p.entry.version.clone(),
+            })
+            .collect();
+        let key: Vec<String> = updates.iter().map(|u| format!("{}@{}", u.id, u.version)).collect();
+        if std::mem::replace(&mut *self.announced_updates.lock(), key.clone()) != key && !updates.is_empty() {
+            self.emit(None, PluginEvent::UpdatesAvailable { updates });
+        }
+    }
+
+    /// Whether the package in `src` would replace the installed `id`'s copy
+    /// with one signed by another key than that copy, without that key's
+    /// endorsement: the user confirms the change of signer.
+    pub(super) fn signer_changed(&self, id: &str, src: &Path) -> bool {
+        let Some(current) = install::active_dir(&self.plugins_dir.join(id)) else { return false };
+        let market = self.market.read();
+        !package::signer_continues(market.as_ref(), read_signature(&current).as_ref(), read_signature(src).as_ref())
+    }
+
+    /// The plugins of the last index read.
+    pub fn market_plugins(&self) -> Vec<MarketPlugin> {
+        let Some(index) = self.market.read().clone() else { return Vec::new() };
+        let plugins = self.plugins.read();
+        index
+            .offered()
+            .into_iter()
+            .map(|(entry, compatible)| {
+                let installed = plugins
+                    .get(&entry.id)
+                    .filter(|p| p.source == PluginSource::Installed)
+                    .map(|p| p.manifest().version.clone());
+                MarketPlugin { entry: entry.clone(), installed, compatible }
+            })
+            .collect()
+    }
+
+    /// Downloads a marketplace plugin, checks it against the index (digest and
+    /// signature), and unpacks it for the install page. Returns the folder to
+    /// install from.
+    pub fn download_market_plugin(&self, id: &str) -> IdeResult<PathBuf> {
+        let url = self.market_url().ok_or_else(|| IdeError::unavailable("no plugin marketplace is configured"))?;
+        let index = self.market.read().clone().ok_or_else(|| IdeError::unavailable("refresh the marketplace first"))?;
+        let (entry, compatible) = index
+            .offered()
+            .into_iter()
+            .find(|(e, _)| e.id == id)
+            .map(|(e, ok)| (e.clone(), ok))
+            .ok_or_else(|| IdeError::not_found(format!("{id} is not in the marketplace")))?;
+        if !compatible {
+            return Err(IdeError::unavailable(format!(
+                "{} {} needs plugin API {}: update OpenIDEA",
+                entry.name, entry.version, entry.engine
+            )));
+        }
+        let bytes = read_url(&resolve(&url, &entry.download), MAX_PACKAGE).map_err(IdeError::unavailable)?;
+        let downloads = self.plugins_dir.join(DOWNLOADS);
+        std::fs::create_dir_all(&downloads)?;
+        let archive = downloads.join(format!("{}-{}.{}", entry.id, entry.version, package::PACKAGE_EXTENSION));
+        std::fs::write(&archive, bytes)?;
+        let dir = self.unpack_package(&archive)?;
+        let _ = std::fs::remove_file(&archive);
+        let manifest = Manifest::load(&dir).map_err(IdeError::invalid)?;
+        let files = self.package_files_in(&dir)?;
+        let digest = package::package_digest(&dir, &files)?;
+        if (manifest.id.as_str(), manifest.version.as_str(), digest.as_str())
+            != (&entry.id, &entry.version, &entry.digest)
+        {
+            let _ = std::fs::remove_dir_all(&dir);
+            return Err(IdeError::invalid("the download does not match the marketplace's entry"));
+        }
+        if self.verified_publisher(&dir).is_none() {
+            let _ = std::fs::remove_dir_all(&dir);
+            return Err(IdeError::invalid("the marketplace package is not signed by a trusted publisher"));
+        }
+        Ok(dir)
+    }
+
+    /// Unpacks a package file (`.oiplugin`, or a `.zip` of a package) next to the downloads; returns the folder.
+    pub fn unpack_package(&self, archive: &Path) -> IdeResult<PathBuf> {
+        let stem = archive.file_stem().and_then(|s| s.to_str()).unwrap_or("package");
+        let dir = self.plugins_dir.join(DOWNLOADS).join(format!("{stem}-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        let unpacked = package::unpack(archive, &dir).map_err(IdeError::invalid)?;
+        // Kept with the files: install checks it and keeps it with the installed copy.
+        if let Some(sig) = unpacked.signature {
+            let json = serde_json::to_string_pretty(&sig).map_err(|e| IdeError::internal(e.to_string()))?;
+            std::fs::write(dir.join(SIGNATURE_FILE), json)?;
+        }
+        Ok(dir)
+    }
+
+    /// Writes a package the UI generated (an imported IntelliJ theme) into a
+    /// folder next to the downloads, named after `name` (its plugin id); returns the folder.
+    /// The install page validates it like any other package.
+    pub fn stage_package(&self, name: &str, files: &[PackageFile]) -> IdeResult<PathBuf> {
+        ide_extension::validate_item_id(name, "package name").map_err(IdeError::invalid)?;
+        if !files.iter().any(|f| f.path == MANIFEST_FILE) {
+            return Err(IdeError::invalid(format!("a package needs a {MANIFEST_FILE}")));
+        }
+        let total: usize = files.iter().map(|f| f.text.len()).sum();
+        if files.len() > MAX_STAGED_FILES || total > MAX_STAGED_BYTES {
+            return Err(IdeError::invalid("the package is too large"));
+        }
+        let mut seen = std::collections::HashSet::new();
+        for f in files {
+            let valid = !f.path.is_empty()
+                && f.path.len() <= 255
+                && f.path.split('/').all(|part| {
+                    !matches!(part, "" | "." | "..") && !part.contains(['\\', ':', '\0']) && !part.starts_with('.')
+                });
+            if !valid {
+                return Err(IdeError::invalid(format!("invalid package path {:?}", f.path)));
+            }
+            if !seen.insert(f.path.to_ascii_lowercase()) {
+                return Err(IdeError::invalid(format!("{} is in the package twice", f.path)));
+            }
+        }
+        // One folder per package, replaced by the next import of it: they don't pile up.
+        let dir = self.plugins_dir.join(DOWNLOADS).join(format!("{name}-generated"));
+        let _ = std::fs::remove_dir_all(&dir);
+        for f in files {
+            let path = dir.join(&f.path);
+            if let Some(parent) = path.parent() {
+                std::fs::create_dir_all(parent)?;
+            }
+            std::fs::write(&path, &f.text)?;
+        }
+        Ok(dir)
+    }
+
+    /// Files of the package in `dir` (what its declarations reference, and
+    /// the component): what a package file holds besides the manifest.
+    pub fn package_files_of(&self, dir: &Path) -> IdeResult<Vec<PathBuf>> {
+        self.package_files_in(dir)
+    }
+
+    pub(super) fn package_files_in(&self, dir: &Path) -> IdeResult<Vec<PathBuf>> {
+        let manifest = Manifest::load(dir).map_err(IdeError::invalid)?;
+        let pkg = ide_extension::Package::new(manifest, dir.to_path_buf());
+        let set = self.registry.prepare(&pkg).map_err(IdeError::invalid)?;
+        Ok(set.files.into_iter().chain(pkg.manifest.wasm.clone()).collect())
+    }
+
+    /// The publisher whose valid, trusted signature the package in `dir` carries.
+    pub(super) fn verified_publisher(&self, dir: &Path) -> Option<String> {
+        let sig = read_signature(dir)?;
+        let index = self.market.read().clone()?;
+        let manifest = Manifest::load(dir).ok()?;
+        let files = self.package_files_in(dir).ok()?;
+        let digest = package::package_digest(dir, &files).ok()?;
+        index
+            .verify(&sig, &manifest.id, &manifest.version, &digest)
+            .map_err(|e| tracing::warn!("{}: {e}", dir.display()))
+            .ok()
+    }
+
+    /// A signature that is present but doesn't verify (tampered, foreign prefix,
+    /// revoked or unknown key): installing is refused.
+    pub(super) fn signature_problem(&self, dir: &Path) -> Option<String> {
+        let sig = read_signature(dir)?;
+        let manifest = Manifest::load(dir).ok()?;
+        let files = self.package_files_in(dir).ok()?;
+        let digest = package::package_digest(dir, &files).ok()?;
+        if let Err(e) = sig.check(&manifest.id, &manifest.version, &digest) {
+            return Some(e);
+        }
+        let index = self.market.read().clone()?;
+        index.verify(&sig, &manifest.id, &manifest.version, &digest).err()
+    }
+
+    /// Why an installed plugin must not run (index revocations, revoked signing key).
+    pub(super) fn revoked_reason(&self, id: &str, version: &str, dir: &Path) -> Option<String> {
+        let market = self.market.read();
+        let index = market.as_ref()?;
+        if let Some(r) = index.revocation(id, version) {
+            return Some(r.reason.clone());
+        }
+        let sig = read_signature(dir)?;
+        index.key_revoked(&sig.key).then(|| "its publisher's signing key was revoked".to_owned())
+    }
+
+    /// Disables installed plugins the index revokes (telling the user once),
+    /// and starts again those it no longer revokes.
+    pub(super) fn apply_revocations(&self) {
+        let installed: Vec<_> =
+            self.plugins.read().values().filter(|p| p.source == PluginSource::Installed).cloned().collect();
+        let mut changed = false;
+        for plugin in installed {
+            let reason = self.revoked_reason(plugin.id(), &plugin.manifest().version, plugin.dir());
+            let current = plugin.meta.lock().error.clone().filter(|e| e.starts_with("revoked: "));
+            match (reason, current) {
+                (Some(r), Some(c)) if c == format!("revoked: {r}") => {}
+                (Some(reason), was) => {
+                    self.stop(&plugin);
+                    {
+                        let mut meta = plugin.meta.lock();
+                        meta.status = PluginStatus::Failed;
+                        meta.error = Some(format!("revoked: {reason}"));
+                    }
+                    if was.is_none() {
+                        self.emit(
+                            None,
+                            super::PluginEvent::Notification {
+                                plugin_id: plugin.id().to_owned(),
+                                level: ide_plugin::NotificationLevel::Warning,
+                                title: format!("{} was disabled", plugin.manifest().name),
+                                body: format!("The marketplace revoked this plugin: {reason}"),
+                            },
+                        );
+                    }
+                    changed = true;
+                }
+                (None, Some(_)) => {
+                    {
+                        let mut meta = plugin.meta.lock();
+                        meta.status = PluginStatus::Inactive;
+                        meta.error = None;
+                    }
+                    if !self.state.lock().disabled.contains(plugin.id()) {
+                        self.start(&plugin);
+                    }
+                    changed = true;
+                }
+                (None, None) => {}
+            }
+        }
+        if changed {
+            self.changed();
+        }
+    }
+}
+
+pub(super) fn read_signature(dir: &Path) -> Option<PackageSignature> {
+    let text = std::fs::read_to_string(dir.join(SIGNATURE_FILE)).ok()?;
+    serde_json::from_str(&text).ok()
+}
+
+/// Keeps the signature of a package with its installed copy.
+pub(super) fn copy_signature(src: &Path, installed: &Path) {
+    if src.join(SIGNATURE_FILE).is_file() {
+        let _ = std::fs::copy(src.join(SIGNATURE_FILE), installed.join(SIGNATURE_FILE));
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn downloads_resolve_against_the_index() {
+        assert_eq!(resolve("https://x.dev/market/index.json", "p/a.oiplugin"), "https://x.dev/market/p/a.oiplugin");
+        assert_eq!(
+            Path::new(&resolve("/srv/market/index.json", "a.oiplugin")),
+            Path::new("/srv/market").join("a.oiplugin")
+        );
+        #[cfg(windows)]
+        assert_eq!(resolve(r"C:\market\index.json", "a.oiplugin"), r"C:\market\a.oiplugin");
+        assert_eq!(resolve("https://x.dev/index.json", "https://cdn.dev/a"), "https://cdn.dev/a");
+    }
+}