chore(plugins): regenerate bindings on top of main

test(plugins): the MyBatis test asks again while the first call builds the index
test(plugins): capability paths are the platform's in the parse test
2026-11-08 08:08:16 -10:00 · 2026-11-04 02:41:46 +08:00 · 2026-11-04 02:41:46 +08:00 · 2026-11-04 02:41:46 +08:00 · 2026-11-04 02:41:46 +08:00 · 2026-11-04 02:41:46 +08:00
1915 changed files with 12762 additions and 216916 deletions
@@ -1,4 +1,4 @@
-<!-- If this resolves an issue: Closes #<n> -->
+Closes #

 ## What and why

@@ -9,8 +9,7 @@

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

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

-permissions:
-  contents: read
-
 concurrency:
  group: ci-${{ github.ref }}
  # A newer push supersedes the run in progress, on main too.
@@ -18,64 +15,20 @@ concurrency:
 env:
  CARGO_TERM_COLOR: always
  CARGO_INCREMENTAL: 0
-  # Line tables keep test backtraces readable; full debuginfo only adds build time and cache size.
-  CARGO_PROFILE_DEV_DEBUG: line-tables-only

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

  deny:
    name: Cargo deny
-    needs: changes
-    if: needs.changes.outputs.rust == 'true'
-    timeout-minutes: 15
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
      - uses: taiki-e/install-action@cargo-deny
      - run: cargo deny check

  frontend:
    name: Frontend
-    needs: changes
-    if: needs.changes.outputs.frontend == 'true'
-    timeout-minutes: 30
    runs-on: ubuntu-22.04
    steps:
-      - uses: actions/checkout@v5
-      - uses: pnpm/action-setup@v5
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
        with: { version: 11 }
-      - uses: actions/setup-node@v5
+      - uses: actions/setup-node@v4
        with: { node-version: 22, cache: pnpm }
      - run: pnpm install --frozen-lockfile
      - run: pnpm typecheck
@@ -209,23 +150,20 @@ jobs:

  e2e:
    name: E2E
-    needs: changes
-    if: needs.changes.outputs.frontend == 'true'
-    timeout-minutes: 30
    runs-on: ubuntu-24.04
    # Browsers and their system libraries are preinstalled; keep the tag in step with @playwright/test.
    container: mcr.microsoft.com/playwright:v1.64.1-noble
    steps:
-      - uses: actions/checkout@v5
-      - uses: pnpm/action-setup@v5
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
        with: { version: 11 }
-      - uses: actions/setup-node@v5
+      - uses: actions/setup-node@v4
        with: { node-version: 22, cache: pnpm }
      - run: pnpm install --frozen-lockfile
      - run: pnpm e2e
        env:
          HOME: /root
-      - uses: actions/upload-artifact@v6
+      - uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: playwright-report
@@ -1,52 +0,0 @@
-name: CNB mirror
-
-# Copies a published release to cnb.cool/l0ng-ai/openidea, the updater's CNB source
-# (scripts/cnb-mirror.ts). Release runs it after publishing; run it by hand to mirror
-# an existing tag again. Skipped without the CNB_TOKEN secret.
-on:
-  workflow_call:
-    inputs:
-      tag: { type: string, required: true }
-  workflow_dispatch:
-    inputs:
-      tag:
-        description: "Published release to mirror (e.g. v0.1.38)"
-        required: true
-
-permissions:
-  contents: read
-
-concurrency:
-  group: cnb-mirror-${{ inputs.tag }}
-
-jobs:
-  mirror:
-    runs-on: ubuntu-latest
-    timeout-minutes: 120
-    env:
-      TAG: ${{ inputs.tag }}
-      CNB_TOKEN: ${{ secrets.CNB_TOKEN }}
-      GH_TOKEN: ${{ github.token }}
-    steps:
-      - name: Check token
-        id: token
-        run: |
-          if [ -z "$CNB_TOKEN" ]; then
-            echo "::notice::CNB_TOKEN unset: not mirroring $TAG"
-            echo "skip=true" >> "$GITHUB_OUTPUT"
-          fi
-      - uses: actions/checkout@v5
-        if: steps.token.outputs.skip != 'true'
-        with: { sparse-checkout: scripts }
-      - uses: actions/setup-node@v5
-        if: steps.token.outputs.skip != 'true'
-        with: { node-version: 22 }
-      - name: Download release
-        if: steps.token.outputs.skip != 'true'
-        run: |
-          gh release download "$TAG" -R "$GITHUB_REPOSITORY" -D assets
-          gh release view "$TAG" -R "$GITHUB_REPOSITORY" --json body,isPrerelease > assets/release.json
-          du -sh assets
-      - name: Upload to CNB
-        if: steps.token.outputs.skip != 'true'
-        run: node scripts/cnb-mirror.ts "$TAG" assets
@@ -1,125 +0,0 @@
-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.
-# Opening the fixture with its build tool and SDK (Maven / Gradle sync, the virtualenv, the
-# JDK): the ignored tests of crates/ide-host/tests/project_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; and debugging its
-# entry point with the debugger the IDE installs (breakpoint, frames, variables, evaluate,
-# Step Over, Resume): smoke/debug.test.ts.
-on:
-  push:
-    branches: [main]
-    paths: &paths
-      - "crates/**"
-      - "languages/**"
-      - "fixtures/**"
-      - "Cargo.toml"
-      - "Cargo.lock"
-      - "src/features/run/**"
-      - "src/features/debugger/**"
-      - "src/platform/**"
-      - "smoke/**"
-      - "package.json"
-      - "pnpm-lock.yaml"
-      - ".github/workflows/language-smoke.yml"
-  pull_request:
-    branches: [main]
-    types: [opened, synchronize, reopened]
-    paths: *paths
-  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 }}
-      - if: matrix.language == 'java'
-        run: cargo test --locked -p ide-host --test project_smoke -- --ignored --exact maven_sync jdk
-      - if: matrix.language == 'kotlin'
-        run: cargo test --locked -p ide-host --test project_smoke -- --ignored --exact gradle_sync
-      - if: matrix.language == 'python'
-        run: cargo test --locked -p ide-host --test project_smoke -- --ignored --exact python_venv
-
-      - 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 }}$"
-      - run: pnpm smoke smoke/debug.test.ts -t "^${{ matrix.language }}$"
-        # The IDE installs the debugger from GitHub releases: authenticated, against rate limits.
-        env: { GITHUB_TOKEN: "${{ github.token }}" }
@@ -1,46 +0,0 @@
-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
@@ -18,15 +18,24 @@ jobs:
    if: github.event.pull_request.user.type != 'Bot' && !github.event.pull_request.draft
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/github-script@v8
+      - uses: actions/github-script@v7
        with:
          script: |
            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.');
@@ -18,7 +18,6 @@ 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.
@@ -26,9 +25,8 @@ jobs:
    runs-on: ubuntu-latest
    outputs:
      release_id: ${{ steps.release.outputs.id }}
-      official_plugin_keys: ${{ steps.plugin-keys.outputs.keys }}
    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
        with: { ref: "${{ env.TAG }}" }
      - name: Tag matches app version
        run: |
@@ -37,32 +35,8 @@ jobs:
            echo "::error::tag $TAG does not match tauri.conf.json version $app"
            exit 1
          fi
-      # A shipped plugin API is frozen: its WIT must be the snapshot api_frozen.rs checks later
-      # versions against (plugins/README.md, "Evolving the plugin API").
-      - name: Plugin API snapshot matches wit/
-        run: |
-          api() { sed -n 's/^package openidea:plugin@\(.*\);$/\1/p' "$1/plugin.wit"; }
-          snapshot=sdk/rust/openidea-plugin/tests/api/released
-          if [ "$(api wit)" != "$(api "$snapshot")" ]; then
-            echo "::error::plugin API $(api wit) ships without a snapshot ($snapshot is $(api "$snapshot")): copy wit/*.wit to $snapshot/"
-            exit 1
-          fi
-      # The official plugins' public key (from PLUGIN_SIGNING_KEY, the seed
-      # `openidea-plugin keygen` writes), built into the app: their packages
-      # must carry its signature whatever the marketplace index lists. Without
-      # 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@v8
+        uses: actions/github-script@v7
        with:
          script: |
            const tag = process.env.TAG;
@@ -83,8 +57,6 @@ 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:
@@ -109,11 +81,11 @@ jobs:
            target: x86_64-pc-windows-msvc
    runs-on: ${{ matrix.os }}
    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
        with: { ref: "${{ env.TAG }}" }
-      - uses: pnpm/action-setup@v5
+      - uses: pnpm/action-setup@v4
        with: { version: 11 }
-      - uses: actions/setup-node@v5
+      - uses: actions/setup-node@v4
        with: { node-version: 22, cache: pnpm }
      - uses: dtolnay/rust-toolchain@stable
        with: { targets: "${{ matrix.target }}" }
@@ -166,28 +138,6 @@ jobs:
            xcrun stapler staple "$dmg"
            gh release upload "$TAG" "$dmg" --clobber
          done
-      # Portable Windows builds (#1857): on Windows Tauri embeds the
-      # frontend in the exe and WebView2 is a system component, so zipping
-      # the raw exe gives an unpack-and-run alternative to the installers.
-      - name: Portable zip
-        if: runner.os == 'Windows'
-        shell: pwsh
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          $target = "${{ matrix.target }}"
-          $arch = if ($target -like "x86_64*") { "x64" } else { "arm64" }
-          $version = $env:TAG -replace '^v', ''
-          $asset = "OpenIDEA_${version}_windows_${arch}_portable.zip"
-          $dir = "target/$target/release"
-          $files = @("$dir/openidea.exe")
-          if (Test-Path "$dir/WebView2Loader.dll") {
-            $files += "$dir/WebView2Loader.dll"
-          }
-          Compress-Archive -Path $files -DestinationPath $asset -Force
-          $hash = (Get-FileHash $asset -Algorithm SHA256).Hash.ToLower()
-          "$hash  $asset" | Out-File -Encoding ascii "$asset.sha256"
-          gh release upload $env:TAG $asset "$asset.sha256" --clobber

  # The remote development server, per host platform it can run on. The desktop
  # app downloads the one for the host (ide-tools `server`) and installs it over SSH.
@@ -205,7 +155,7 @@ jobs:
          - { runner: macos-latest, target: x86_64-apple-darwin, os: macos, arch: x86_64 }
    runs-on: ${{ matrix.runner }}
    steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
        with: { ref: "${{ env.TAG }}" }
      - uses: dtolnay/rust-toolchain@stable
        with: { targets: "${{ matrix.target }}" }
@@ -234,11 +184,7 @@ jobs:
  # (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.
+  # writes) nothing is published and the release goes on.
  plugins:
    needs: create-release
    name: Official plugins
@@ -252,7 +198,7 @@ jobs:
            echo "::warning::PLUGIN_SIGNING_KEY is not set: the official plugins are not published"
            echo "skip=true" >> "$GITHUB_OUTPUT"
          fi
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
        if: steps.key.outputs.skip != 'true'
        with: { ref: "${{ env.TAG }}" }
      - uses: dtolnay/rust-toolchain@stable
@@ -261,10 +207,10 @@ jobs:
      - uses: Swatinem/rust-cache@v2
        if: steps.key.outputs.skip != 'true'
        with: { key: release-plugins }
-      - uses: pnpm/action-setup@v5
+      - uses: pnpm/action-setup@v4
        if: steps.key.outputs.skip != 'true'
        with: { version: 11 }
-      - uses: actions/setup-node@v5
+      - 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.
@@ -291,17 +237,11 @@ jobs:
            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.
+          # The published index's revocations and earlier keys 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
+          "$tool" index "$out" --publisher openidea --name OpenIDEA --key "$key" --out "$out/plugins-index.json"
+          gh release upload "$TAG" "$out"/*.oiplugin "$out/plugins-index.json" --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.
@@ -309,7 +249,7 @@ jobs:
    needs: [create-release, build]
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/github-script@v8
+      - uses: actions/github-script@v7
        env:
          RELEASE_ID: ${{ needs.create-release.outputs.release_id }}
        with:
@@ -369,7 +309,7 @@ jobs:
    needs: [create-release, build, server, plugins, updater-manifest]
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/github-script@v8
+      - uses: actions/github-script@v7
        env:
          RELEASE_ID: ${{ needs.create-release.outputs.release_id }}
        with:
@@ -377,10 +317,3 @@ jobs:
            await github.rest.repos.updateRelease({
              ...context.repo, release_id: Number(process.env.RELEASE_ID), draft: false,
            });
-
-  # The China mirror the updater's CNB source reads; a failure here leaves the GitHub release as is.
-  cnb-mirror:
-    needs: publish
-    uses: ./.github/workflows/cnb-mirror.yml
-    with: { tag: "${{ github.event.inputs.tag || github.ref_name }}" }
-    secrets: inherit
@@ -11,7 +11,6 @@
    "src/bindings.ts",
    "src/editor/core/cm/angular/parser*.ts",
    "src/editor/core/cm/jsp/parser*.ts",
-    "src/editor/core/cm/astro/parser*.ts",
    "docs/plugins/themes.md",
    "pnpm-lock.yaml",
    "**/*.toml",
@@ -14,7 +14,6 @@
    "crates",
    "src/bindings.ts",
    "src/editor/core/cm/angular/parser*.ts",
-    "src/editor/core/cm/astro/parser*.ts",
    "fixtures",
    "plugins",
    "test-results",
@@ -18,12 +18,9 @@ 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 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`.
+- `crates/ide-host` — the `openidea-server` binary for remote development.
+- `wit/` — plugin interface definitions; `plugins/` — sample and bundled plugins;
+  `templates/` — plugin starter templates.
 - `e2e/` — Playwright UI tests (`pnpm e2e`). `fixtures/` — sample projects per language
  for manual and automated testing.

@@ -42,17 +39,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 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, when the change alters what users
-see, before/after screenshots (not for UI removed along with a feature, copy-only or non-visual changes).
+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
+**How it was verified** section with commands run, results and (for UI) before/after screenshots.
 Unclear product decisions → `needs-decision` and stop.

 ## Skills
@@ -68,19 +63,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 smoke smoke/debug.test.ts -t <language>` — debug that fixture's entry point the same way, with
-  the debugger the IDE installs (on macOS, CodeLLDB and Delve may need Developer Mode:
-  `sudo DevToolsSecurity -enable`).
 - `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
  benches vs budgets). Budgets: `perf/budgets.json`.
- `pnpm release:prepare <version>` — the release commit's changes: app version everywhere,
-  `Cargo.lock`, and the plugin API snapshot when `wit/` moved to a new version.

 ## Before opening a PR

@@ -124,8 +110,8 @@ Several worktrees can be developed and run side by side.
  default MCP session belongs to this worktree.
 - Keep each worktree's Cargo output directory separate; do not point `CARGO_TARGET_DIR` or
  `target` symlinks at a shared directory.
- Each worktree's first build is cold (several minutes) and `cargo build` output takes
-  around 9 GB; tests, clippy and incremental builds add more. Avoid running several heavy builds on one machine at the same time.
+- Each worktree's first build is cold (around 5 minutes) and its Cargo output takes
+  15–30 GB. Avoid running several heavy builds on one machine at the same time.
 - Stop only processes started for the current worktree/session. Never use broad
  process-name kills such as `pkill openidea`.
 - When done: stop that worktree's app and dev session, delete its build output, then
@@ -16,7 +16,8 @@ Project layout, coding rules, commands and checks are in [AGENTS.md](AGENTS.md).

 ## Pull requests

- One problem per PR. If it resolves an issue, link it with `Closes #123`.
+- One issue per PR, linked with `Closes #123`. Feature PRs need a `planned` issue.
+  Docs, CI and pure refactors may skip the issue.
 - 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.
@@ -25,15 +26,10 @@ Project layout, coding rules, commands and checks are in [AGENTS.md](AGENTS.md).
 - Fill in the template. Keep the description short and in plain words. If it
  doesn't fit in a few sentences, the PR is probably too big.
 - **How it was verified** is required: the commands you ran and their results,
-  and what else the change could affect. Changes to what users see need before/after
-  screenshots; multi-step interactions need a recording. UI that goes away with a removed
-  feature, copy-only and non-visual changes don't; say what you checked instead.
+  and what else the change could affect. UI changes need before/after screenshots;
+  multi-step interactions need a recording.
 - If a change needs a product decision you can't make, ask in the issue and stop
  rather than guessing.

-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.
+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.
@@ -5,7 +5,7 @@ members = ["crates/*", "src-tauri"]
 exclude = ["sdk", "plugins"]

 [workspace.package]
-version = "0.1.38"
+version = "0.1.35"
 edition = "2024"
 rust-version = "1.96"
 license = "Apache-2.0"
@@ -76,6 +76,7 @@ ignore = "0.4"
 base64 = "0.22"
 globset = "0.4"
 notify = "8"
+notify-debouncer-full = "0.6"
 trash = "5"
 blake3 = "1"
 dunce = "1"
@@ -85,7 +86,6 @@ 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"
@@ -103,12 +103,8 @@ rustls = { version = "0.23", default-features = false, features = ["ring", "std"
 rustls-platform-verifier = "0.7"
 sqlx = { version = "0.9", default-features = false, features = ["runtime-tokio", "tls-rustls-ring-webpki", "sqlite", "postgres", "mysql"] }
 tiberius = { version = "0.13", default-features = false, features = ["tds73", "rustls", "sql-browser-tokio"] }
-oracle = { version = "0.6", default-features = false }
 bb8 = "0.9"
 uuid = { version = "1", features = ["v4"] }
-# OS credential stores
-keyring = "4.2"
-keyring-core = "1"

 # testing
 insta = { version = "1", features = ["yaml"] }
@@ -118,14 +114,8 @@ tempfile = "3"
 [profile.dev]
 # Keep debug builds snappy while giving dependencies decent speed.
 opt-level = 0
-# Full debug info is most of target/. Line tables keep file:line in our backtraces, but a
-# debugger can't show locals; re-enable with `--config profile.dev.debug=true`.
-debug = "line-tables-only"
 [profile.dev.package."*"]
 opt-level = 2
-# Dependency frames keep function names only. Re-enable one with
-# `--config 'profile.dev.package.<crate>.debug=true'`.
-debug = false

 [profile.release]
 codegen-units = 1
@@ -14,9 +14,7 @@
  &nbsp;·&nbsp;
  <a href="#benchmark">Benchmark</a>
  &nbsp;·&nbsp;
-  <a href="#plugins">Plugins</a>
-  &nbsp;·&nbsp;
-  <a href="#community">Community</a>
+  <a href="https://discord.gg/2Zy4yn7gP">Discord</a>
 </p>

 https://github.com/user-attachments/assets/234dd54c-1255-4b3a-b35c-533d78d737c0
@@ -25,9 +23,7 @@ OpenIDEA brings the IntelliJ IDEA way of working — its keymap, its tool window
 its search-everything habits — to a native app with a Rust core.

 Editor, code insight, debugger, Git, terminal, database and HTTP clients,
-for 60+ languages. Builds for macOS, Windows and Linux. On Windows, if you'd
-rather skip the installer, each release also ships a portable zip — unpack it
-and run `openidea.exe`.
+for 60+ languages. Builds for macOS, Windows and Linux.

 ## Benchmark

@@ -49,29 +45,6 @@ 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.
-
-## Community
-
- [Discord](https://discord.gg/2Zy4yn7gP) — questions, feedback and release news.
- WeChat group — scan to join:
-
-  <img src="docs/assets/wechat-group.png" alt="WeChat group QR code" width="200">
-
-### Contributors
-
-<a href="https://github.com/l0ng-ai/openidea/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=l0ng-ai/openidea&max=100" alt="OpenIDEA contributors">
-</a>
-
 ## License

 [Apache 2.0](LICENSE). Bundled third-party assets are listed in [`THIRD_PARTY_LICENSES.md`](THIRD_PARTY_LICENSES.md).
@@ -2,13 +2,12 @@

 ## Project Lombok

-`java/lombok/lombok-1.18.48-openidea.3.jar` contains Project Lombok v1.18.48 with the Equinox
-classloader fix from [projectlombok/lombok#4059](https://github.com/projectlombok/lombok/pull/4059),
-the [compact record constructor builder fix](java/lombok/patches/builder-compact-constructor.patch)
+`plugins/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 [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).
+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).

 ## JetBrains IntelliJ Platform icons

@@ -34,8 +33,7 @@ icon set, copied unmodified (some renamed) from JetBrains' open-source repositor
 - [intellij-plugins](https://github.com/JetBrains/intellij-plugins) (each plugin
  carries its own licence): `protobuf/protoeditor-core` (`newui/protoFile` →
  `fileTypes/protoFile`, Apache-2.0); `terraform` (`newui/hashiCorp` →
-  `fileTypes/hashiCorp`, Apache-2.0); `Astro` (`icons/astro` → `fileTypes/astro`,
-  Apache-2.0); `makefile` (`expui/makefile` →
+  `fileTypes/hashiCorp`, Apache-2.0); `makefile` (`expui/makefile` →
  `fileTypes/makefile`, MIT, Copyright (c) 2016 Victor Kropp — full text below).

 The read/write usage filter assets (`actions/showReadAccess{,_dark}.svg` and
@@ -54,15 +52,6 @@ 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
@@ -54,15 +54,10 @@ const SESSION_STATE: [&str; 5] =
 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";
-/// A native agent's own update: the background tasks its session runs
-/// (see [`TaskState::background_tasks`]).
-pub(crate) const BACKGROUND_TASKS_UPDATE: &str = "openidea_background_tasks";
 /// 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 {
@@ -109,9 +104,6 @@ struct Shared {
 struct Known {
    #[serde(default)]
    config: Vec<AgentConfigOption>,
-    /// Thinking levels reported for each model value, including its last choice.
-    #[serde(default, rename = "thoughtLevels")]
-    thought_levels: BTreeMap<String, Vec<AgentConfigOption>>,
    /// By project root: skills and custom commands differ per project.
    #[serde(default, rename = "projectCommands")]
    commands: HashMap<String, Vec<AgentCommand>>,
@@ -131,8 +123,6 @@ impl Shared {

    fn known_config(&self, provider: &str) -> Vec<AgentConfigOption> {
        let mut config = self.known.lock().get(provider).map(|k| k.config.clone()).unwrap_or_default();
-        // Model-specific options are offered separately, never as provider-wide defaults.
-        config.retain(|o| o.category.as_deref() != Some("thought_level"));
        config::add_client_options(provider, &mut config);
        if let Some((o, v)) = config::bypass_mode(&config).map(|(o, v)| (o.id.clone(), v.value.clone()))
            && let Some(o) = config.iter_mut().find(|c| c.id == o)
@@ -155,31 +145,14 @@ impl Shared {
        self.paths.project_root.to_string_lossy().into_owned()
    }

-    /// Cache levels only when `model` confirms which model the session reported them for.
-    fn remember(
-        &self,
-        provider: &str,
-        config: Option<&[AgentConfigOption]>,
-        commands: Option<&[AgentCommand]>,
-        model: Option<&str>,
-    ) {
+    fn remember(&self, provider: &str, config: Option<&[AgentConfigOption]>, commands: Option<&[AgentCommand]>) {
        let snapshot = {
            let mut cache = self.known.lock();
            let known = cache.entry(provider.to_owned()).or_default();
            let mut changed = false;
-            if let Some(c) = config {
-                if let Some(model) = model {
-                    let levels: Vec<_> =
-                        c.iter().filter(|o| o.category.as_deref() == Some("thought_level")).cloned().collect();
-                    if known.thought_levels.get(model) != Some(&levels) {
-                        known.thought_levels.insert(model.to_owned(), levels);
-                        changed = true;
-                    }
-                }
-                if !c.is_empty() && known.config != c {
-                    known.config = c.to_vec();
-                    changed = true;
-                }
+            if let Some(c) = config.filter(|c| !c.is_empty() && known.config != *c) {
+                known.config = c.to_vec();
+                changed = true;
            }
            let root = self.root_key();
            if let Some(c) =
@@ -218,9 +191,6 @@ struct TaskFile {
    /// Turns to drop from the session once it is loaded (a fork of an earlier point).
    #[serde(default, skip_serializing_if = "is_zero")]
    pending_rollback: u32,
-    /// The user named the task: its agent's own title updates no longer replace it.
-    #[serde(default, skip_serializing_if = "is_false")]
-    title_renamed: bool,
 }

 struct TaskState {
@@ -230,20 +200,13 @@ struct TaskState {
    wanted: Vec<AgentConfigChoice>,
    before: Arc<BTreeMap<String, worktree::Stamp>>,
    pending_rollback: u32,
-    /// The user named the task; see `TaskFile::title_renamed`.
-    title_renamed: bool,
    /// A turn is running or about to (prompts arriving now are queued).
    busy: bool,
-    /// Background tasks the agent reported as running (`run_in_background` commands and
-    /// the like), as it sent them: unlike a turn they outlive it, so an idle release
-    /// waits for the last one. A (re)started process runs nothing yet.
-    background_tasks: Vec<Value>,
 }

 /// A running agent and its session.
 #[derive(Clone)]
 struct Live {
-    sign_in_message: String,
    peer: acp::Conn,
    session: String,
    capabilities: AgentCapabilities,
@@ -274,9 +237,6 @@ struct Task {
    turn_started: AtomicBool,
    /// Turns sent so far: an idle release scheduled before the latest one is void.
    turns: AtomicU64,
-    /// Bumped when the agent's last background task finishes: an idle release scheduled
-    /// before that is void, the usual delay starts over from the report.
-    idle_epoch: 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)>>,
@@ -335,7 +295,6 @@ impl AgentManager {
                        f.task.status = AgentStatus::Ready;
                    }
                    f.task.retry = None;
-                    f.task.background.clear();
                    let task = Task::restore(f, shared.clone());
                    task.state.lock().conversation.settle(now_ms());
                    tasks.insert(task.id.clone(), task);
@@ -362,8 +321,6 @@ impl AgentManager {
            .map(|p| {
                let mut info = provider::describe(p);
                info.config = self.shared.known_config(&p.id);
-                info.thought_levels =
-                    self.shared.known.lock().get(&p.id).map(|k| k.thought_levels.clone()).unwrap_or_default();
                info.commands = self.shared.known_commands(&p.id);
                info
            })
@@ -388,14 +345,6 @@ 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());
@@ -483,18 +432,6 @@ impl AgentManager {
                o.current = Some(choice.value.clone());
            }
        }
-        if let Some(model) = model_of(&config)
-            && let Some(levels) = self.shared.known.lock().get(&spec.id).and_then(|k| k.thought_levels.get(&model))
-        {
-            config.extend(levels.iter().cloned().map(|mut o| {
-                if let Some(choice) =
-                    req.config.iter().find(|c| c.id == o.id && o.values.iter().any(|v| v.value == c.value))
-                {
-                    o.current = Some(choice.value.clone());
-                }
-                o
-            }));
-        }
        let now = now_ms();
        let task = AgentTask {
            project_root,
@@ -518,7 +455,6 @@ impl AgentManager {
            capabilities: self.shared.probes.lock().get(&spec.id).map(|p| p.capabilities).unwrap_or_default(),
            resets_ms: None,
            retry: None,
-            background: Box::default(),
        };
        let file = TaskFile {
            task: task.clone(),
@@ -528,7 +464,6 @@ impl AgentManager {
            before,
            subagents: Vec::new(),
            pending_rollback: 0,
-            title_renamed: false,
        };
        let handle = Task::restore(file, self.shared.clone());
        handle.state.lock().busy = true;
@@ -643,8 +578,6 @@ impl AgentManager {
            o.clone()
        };
        let live = task.live.lock().clone().filter(|l| !l.peer.is_closed());
-        let mut model_options =
-            target.category.as_deref() != Some("model") || target.current.as_deref() == Some(value.as_str());
        if let Some(live) = live.filter(|_| option != config::CURSOR_APPROVAL) {
            let (method, mut params) = config::set_request(&target, &value);
            params["sessionId"] = json!(live.session);
@@ -652,14 +585,10 @@ impl AgentManager {
                live.peer.request(method, params, None).await.map_err(|e| IdeError::internal(task.describe(e)))?;
            if let Some(options) = reply.get("configOptions") {
                config::merge_update(&mut task.state.lock().task.config, options);
-                model_options = true;
            }
        }
        {
            let mut s = task.state.lock();
-            if !model_options {
-                s.task.config.retain(|o| o.category.as_deref() != Some("thought_level"));
-            }
            s.wanted.retain(|c| c.id != option);
            s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: value.clone() });
            if let Some(o) = s.task.config.iter_mut().find(|o| o.id == option) {
@@ -668,9 +597,8 @@ impl AgentManager {
            s.task.model = model_of(&s.task.config).or(s.task.model.take());
            let provider = s.task.provider.clone();
            let config = s.task.config.clone();
-            let model = s.task.model.clone().filter(|_| model_options);
            drop(s);
-            task.shared.remember(&provider, Some(&config), None, model.as_deref());
+            task.shared.remember(&provider, Some(&config), None);
        }
        task.approve_pending();
        task.persist();
@@ -721,7 +649,6 @@ impl AgentManager {
                queue: Vec::new(),
                resets_ms: None,
                retry: None,
-                background: Box::default(),
                ..s.task.clone()
            };
            TaskFile {
@@ -732,7 +659,6 @@ impl AgentManager {
                before: (*s.before).clone(),
                subagents: s.conversation.saved_subagents(),
                pending_rollback: total - keep,
-                title_renamed: s.title_renamed,
            }
        };
        let task = Task::restore(file, self.shared.clone());
@@ -751,38 +677,12 @@ impl AgentManager {
        if task.state.lock().busy {
            return Err(IdeError::invalid("wait until the agent is done"));
        }
-        let starts = turn_starts(&task.state.lock().conversation.main.entries);
-        let Some(&cut) = starts.get(turns as usize) else { return Ok(None) };
-        // Dropping every turn starts the conversation over, which needs no agent-side
-        // rewind — and some agents cannot rewind past their first turn (a resumed
-        // Claude Code session). A fresh session avoids both.
-        if turns == 0 {
-            task.kill();
-            let first = {
-                let mut s = task.state.lock();
-                let first = match s.conversation.main.entries.get(cut) {
-                    Some(AgentEntry::User { text, .. }) => {
-                        Some(AgentPrompt { text: text.clone(), ..Default::default() })
-                    }
-                    _ => None,
-                };
-                s.session_id = None;
-                s.conversation = Conversation::default();
-                // The fresh session reports its own usage; nothing carries over.
-                s.task.usage = None;
-                s.pending_rollback = 0;
-                s.task.updated_ms = now_ms();
-                first
-            };
-            task.persist();
-            self.shared.emit(AgentEvent::Truncated { task: id.to_owned(), length: 0 });
-            task.emit_task();
-            return Ok(first);
-        }
        let live = task.ensure_session().await.map_err(IdeError::internal)?;
        if !live.capabilities.rollback {
            return Err(IdeError::invalid("this agent can't undo turns"));
        }
+        let starts = turn_starts(&task.state.lock().conversation.main.entries);
+        let Some(&cut) = starts.get(turns as usize) else { return Ok(None) };
        let drop = (starts.len() - turns as usize) as u32;
        let _: Value = live
            .peer
@@ -887,21 +787,6 @@ impl AgentManager {
        Ok(())
    }

-    /// Stops background task `background` of task `id`.
-    pub async fn stop_background(&self, id: &str, background: &str) -> IdeResult<()> {
-        let task = self.task(id)?;
-        let live = task.live.lock().clone().ok_or_else(|| IdeError::invalid("the agent is not running"))?;
-        if !live.capabilities.background_tasks {
-            return Err(IdeError::invalid("this agent can't stop a background task"));
-        }
-        let _: Value = live
-            .peer
-            .request("_openidea/stop_task", json!({ "sessionId": live.session, "taskId": background }), None)
-            .await
-            .map_err(|error| IdeError::internal(task.describe(error)))?;
-        Ok(())
-    }
-
    /// Answers permission request `permission` with option `option` (`None` cancels it).
    pub fn respond(&self, id: &str, permission: u32, option: Option<String>) -> IdeResult<()> {
        let task = self.task(id)?;
@@ -943,32 +828,10 @@ impl AgentManager {
        Ok(())
    }

-    /// Renames the task; the agent's own later title updates keep the user's choice.
-    pub fn rename(&self, id: &str, title: &str) -> IdeResult<()> {
-        let title = title.trim();
-        if title.is_empty() {
-            return Err(IdeError::invalid("the title is empty"));
-        }
-        let title: String = title.chars().take(200).collect();
-        let task = self.task(id)?;
-        {
-            let mut s = task.state.lock();
-            if s.task.title == title && s.title_renamed {
-                return Ok(());
-            }
-            s.task.title = title;
-            s.title_renamed = true;
-            s.task.updated_ms = now_ms();
-        }
-        task.persist();
-        task.emit_task();
-        Ok(())
-    }
-
    /// 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)?;
-        let live = task.kill();
+        task.kill();
        let (isolation, cwd, root) = {
            let s = task.state.lock();
            (
@@ -980,11 +843,6 @@ 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?;
        }
@@ -1035,9 +893,7 @@ impl Task {
                wanted: file.wanted,
                before: Arc::new(file.before),
                pending_rollback: file.pending_rollback,
-                title_renamed: file.title_renamed,
                busy: false,
-                background_tasks: Vec::new(),
            }),
            live: Mutex::new(None),
            connecting: tokio::sync::Mutex::new(()),
@@ -1048,7 +904,6 @@ impl Task {
            cancel_pending: AtomicBool::new(false),
            turn_started: AtomicBool::new(false),
            turns: AtomicU64::new(0),
-            idle_epoch: AtomicU64::new(0),
            config_sent: Mutex::new(HashSet::new()),
            dirty: Mutex::new(BTreeSet::new()),
            flush_scheduled: AtomicBool::new(false),
@@ -1085,39 +940,6 @@ impl Task {
        self.emit_task();
    }

-    /// Keeps the agent's background tasks that outlive its turn. Returns whether the last
-    /// one just finished, so the idle release starts over from this report.
-    fn set_background_tasks(&self, tasks: Vec<Value>) -> bool {
-        let (emptied, shown) = {
-            let mut state = self.state.lock();
-            if state.background_tasks == tasks {
-                return false;
-            }
-            let emptied = !state.background_tasks.is_empty() && tasks.is_empty();
-            let background = shown_background(&tasks, &state.task.background);
-            let shown = background != *state.task.background;
-            *state.task.background = background;
-            state.background_tasks = tasks;
-            if emptied {
-                // Void a release scheduled while the tasks still ran: it would stop the
-                // agent sooner than the usual delay after this one.
-                self.idle_epoch.fetch_add(1, Ordering::AcqRel);
-            }
-            (emptied, shown)
-        };
-        if shown {
-            self.emit_task();
-        }
-        emptied
-    }
-
-    fn clear_shown_background(&self) {
-        let cleared = !std::mem::take(&mut self.state.lock().task.background).is_empty();
-        if cleared {
-            self.emit_task();
-        }
-    }
-
    fn set_status(&self, status: AgentStatus, error: Option<String>) {
        {
            let mut s = self.state.lock();
@@ -1147,7 +969,6 @@ impl Task {
                before: (*s.before).clone(),
                subagents: s.conversation.saved_subagents(),
                pending_rollback: s.pending_rollback,
-                title_renamed: s.title_renamed,
            })
        };
        let path = self.shared.paths.store_dir.join(format!("{}.json", self.id));
@@ -1237,32 +1058,19 @@ impl Task {
    /// 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.
-    /// A turn's background tasks outlive it: the release waits for the last one, and the
-    /// delay runs again once the agent reports it done.
    fn release_when_idle(self: &Arc<Self>) {
        let turn = self.turns.load(Ordering::Acquire);
-        let epoch = self.idle_epoch.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.idle_epoch.load(Ordering::Acquire) != epoch
                || task.state.lock().busy
                || !task.permissions.lock().is_empty()
            {
                return;
            }
-            // Stopping now would orphan what the agent still runs in the background: its
-            // result would never reach the conversation. Wait for the last task; when it
-            // is done, its report voids this schedule and starts the delay over.
-            let waiting = !task.state.lock().background_tasks.is_empty();
-            if waiting && task.live.lock().as_ref().is_some_and(|l| l.resumable && !l.peer.is_closed()) {
-                tracing::debug!("agent task {}: idle, waiting for its background tasks", task.id);
-                task.release_when_idle();
-                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 }
@@ -1270,7 +1078,6 @@ impl Task {
            if let Some(live) = live {
                tracing::debug!("agent task {}: idle, stopping the agent until the next message", task.id);
                live.peer.kill();
-                task.clear_shown_background();
            }
        });
    }
@@ -1289,7 +1096,6 @@ impl Task {
        if !gone && let Some(live) = self.live.lock().take() {
            live.peer.kill();
        }
-        self.clear_shown_background();
        match failure.limit {
            Some(resets) => {
                self.state.lock().task.resets_ms = resets;
@@ -1397,7 +1203,11 @@ impl Task {
        match e {
            // Signed out, or the account was refused (Claude Code: "API Error: 403").
            RpcError::Server { message, .. } if message.to_lowercase().contains("auth") => {
-                Failure::from(self.live.lock().as_ref().map(|live| live.sign_in_message.clone()).unwrap_or(message))
+                let provider = self.state.lock().task.provider.clone();
+                Failure::from(match self.shared.spec(&provider) {
+                    Some(spec) => format!("{} needs you to sign in. {}", spec.name, spec.login_hint),
+                    None => message,
+                })
            }
            e => Failure::from(self.describe(e)),
        }
@@ -1415,11 +1225,6 @@ impl Task {
            (s.task.provider.clone(), s.task.cwd.0.clone(), s.session_id.clone())
        };
        let spec = self.shared.spec(&provider_id).ok_or_else(|| format!("unknown agent {provider_id}"))?;
-        let launch_cwd = cwd.clone();
-        let spec = tokio::task::spawn_blocking(move || spec.resolve_for_launch(&launch_cwd))
-            .await
-            .map_err(|e| e.to_string())?;
-        let sign_in_message = spec.sign_in_message();
        self.stderr.lock().clear();
        self.config_sent.lock().clear();
        let weak = Arc::downgrade(self);
@@ -1465,7 +1270,7 @@ impl Task {
                    .await
                    .map_err(|e| match e {
                        RpcError::Server { ref message, .. } if message.to_lowercase().contains("auth") => {
-                            sign_in_message.clone()
+                            format!("{} needs you to sign in. {}", spec.name, spec.login_hint)
                        }
                        e => self.describe(e),
                    })?;
@@ -1491,21 +1296,11 @@ impl Task {
        // A session that reports none keeps the last known ones, but what is set is unknown.
        let reported = config::options_of(&result);
        let known = !reported.is_empty();
-        if known {
-            self.shared.remember(&provider_id, Some(&reported), None, model_of(&reported).as_deref());
-        }
-        let (mut options, mut wanted) = {
+        let (mut options, wanted) = {
            let s = self.state.lock();
            (if known { reported } else { s.task.config.clone() }, s.wanted.clone())
        };
        config::add_client_options(&provider_id, &mut options);
-        // Changing model can replace the effort choices; validate those only afterwards.
-        wanted.sort_by_key(|c| match options.iter().find(|o| o.id == c.id).and_then(|o| o.category.as_deref()) {
-            Some("model") => 0,
-            Some("thought_level") => 2,
-            _ => 1,
-        });
-        let mut model_options = known;
        for choice in &wanted {
            // An option the session doesn't offer yet is set once it does (`apply_late_choices`).
            let Some(o) = options.iter().find(|o| o.id == choice.id).cloned() else { continue };
@@ -1515,9 +1310,6 @@ impl Task {
                }
                continue;
            }
-            if o.category.as_deref() == Some("thought_level") && !model_options {
-                continue;
-            }
            let already = known && o.current.as_deref() == Some(choice.value.as_str());
            if already || !o.values.iter().any(|v| v.value == choice.value) {
                continue;
@@ -1529,12 +1321,6 @@ impl Task {
                Ok(reply) => {
                    if let Some(fresh) = reply.get("configOptions") {
                        config::merge_update(&mut options, fresh);
-                        model_options = true;
-                    } else if o.category.as_deref() == Some("model") {
-                        if o.current.as_deref() != Some(choice.value.as_str()) {
-                            options.retain(|o| o.category.as_deref() != Some("thought_level"));
-                        }
-                        model_options = false;
                    }
                    if let Some(o) = options.iter_mut().find(|o| o.id == choice.id) {
                        o.current = Some(choice.value.clone());
@@ -1543,21 +1329,17 @@ impl Task {
                Err(e) => tracing::warn!("agent task {}: setting {} to {} failed: {e}", self.id, o.id, choice.value),
            }
        }
-        let model = model_of(&options).filter(|_| model_options);
-        self.shared.remember(&provider_id, Some(&options), None, model.as_deref());
+        self.shared.remember(&provider_id, Some(&options), None);
        {
            let mut s = self.state.lock();
            s.task.model = model_of(&options).or(s.task.model.take());
            s.task.config = options;
            s.task.capabilities = capabilities;
            s.session_id = Some(session_id.clone());
-            // The (re)started process runs nothing yet: whatever it reports next is all of it.
-            s.background_tasks = Vec::new();
-            s.task.background.clear();
        }
        self.persist();
        self.emit_task();
-        let live = Live { sign_in_message, peer, session: session_id, capabilities, embedded, resumable: can_load };
+        let live = Live { peer, session: session_id, capabilities, embedded, resumable: can_load };
        *self.live.lock() = Some(live.clone());
        Ok(live)
    }
@@ -1593,19 +1375,11 @@ impl Task {
                        let mut s = task.state.lock();
                        if let Some(fresh) = reply.get("configOptions") {
                            config::merge_update(&mut s.task.config, fresh);
-                        } else if option.category.as_deref() == Some("model") {
-                            s.task.config.retain(|o| o.category.as_deref() != Some("thought_level"));
                        }
                        if let Some(o) = s.task.config.iter_mut().find(|o| o.id == option.id) {
                            o.current = Some(value);
                        }
                        s.task.model = model_of(&s.task.config).or(s.task.model.take());
-                        let model = s.task.model.clone().filter(|_| {
-                            reply.get("configOptions").is_some() || option.category.as_deref() != Some("model")
-                        });
-                        let (provider, options) = (s.task.provider.clone(), s.task.config.clone());
-                        drop(s);
-                        task.shared.remember(&provider, Some(&options), None, model.as_deref());
                    }
                    Err(e) => tracing::warn!("agent task {}: setting {} to {value} failed: {e}", task.id, option.id),
                }
@@ -1654,29 +1428,13 @@ impl Task {
            }
            return;
        }
-        if kind == BACKGROUND_TASKS_UPDATE {
-            if !self.replaying.load(Ordering::Acquire) {
-                let tasks = update.get("tasks").and_then(Value::as_array).cloned().unwrap_or_default();
-                // The last one finished while the agent is up: the usual delay starts over.
-                if self.set_background_tasks(tasks) {
-                    self.release_when_idle();
-                }
-            }
-            return;
-        }
        if kind == "session_info_update" {
-            // The agent's own title for the session replaces the first line of the prompt,
-            // unless the user named the task.
+            // 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());
            if let Some(title) = title {
-                // Check and write under one lock: a rename landing between them would be lost.
-                let mut s = self.state.lock();
-                if !s.title_renamed && s.task.title != title {
-                    s.task.title = title.to_owned();
-                    drop(s);
-                    self.persist();
-                    self.emit_task();
-                }
+                self.state.lock().task.title = title.to_owned();
+                self.persist();
+                self.emit_task();
            }
            return;
        }
@@ -1710,15 +1468,11 @@ impl Task {
            }
        };
        if task_changed {
-            let (config, commands, model) = {
+            let (config, commands) = {
                let s = self.state.lock();
-                (
-                    s.task.config.clone(),
-                    s.task.commands.clone(),
-                    s.task.model.clone().filter(|_| kind == "config_option_update"),
-                )
+                (s.task.config.clone(), s.task.commands.clone())
            };
-            self.shared.remember(&provider, Some(&config), Some(&commands), model.as_deref());
+            self.shared.remember(&provider, Some(&config), Some(&commands));
            if kind != "usage_update" {
                self.persist();
            }
@@ -1755,12 +1509,12 @@ impl Task {
    /// Blocks the calling (blocking-pool) thread until the user answers.
    fn ask_permission(self: &Arc<Self>, params: &Value) -> Value {
        let id = self.next_permission.fetch_add(1, Ordering::Relaxed);
-        let (questions, by_index) = asked_questions(params);
-        let title = permission_title(params);
-        // An agent that answers by index titles its request "Ask user N question(s)"; its
-        // first question says what it wants, as the Claude Code adapter titles its own.
-        let title =
-            if by_index { questions.first().map(|question| question.question.clone()).unwrap_or(title) } else { title };
+        let title = params
+            .pointer("/toolCall/title")
+            .and_then(Value::as_str)
+            .filter(|t| !t.is_empty())
+            .unwrap_or("The agent asks for permission")
+            .to_owned();
        // A subagent's request is answered in the task's conversation, named after the subagent.
        let session = params.get("sessionId").and_then(Value::as_str);
        let title = match session.and_then(|s| self.state.lock().conversation.label(s)) {
@@ -1782,37 +1536,17 @@ impl Task {
                    .collect()
            })
            .unwrap_or_default();
-        let asked: Vec<String> = questions
-            .iter()
-            .map(|question| question.answer_key.clone().unwrap_or_else(|| question.question.clone()))
-            .collect();
        let (tx, rx) = std::sync::mpsc::channel();
-        let entry =
-            self.push_entry(AgentEntry::Permission { id, title, options: options.clone(), questions, chosen: None });
+        let entry = self.push_entry(AgentEntry::Permission { id, title, options: options.clone(), chosen: None });
        self.permissions.lock().insert(id, tx);
        self.set_status(AgentStatus::NeedsInput, None);
        self.approve_pending();

        let answer = rx.recv().ok().flatten();
-        let answers = answer
-            .as_deref()
-            .filter(|_| !asked.is_empty())
-            .and_then(|reply| serde_json::from_str::<serde_json::Map<String, Value>>(reply).ok());
-        let name = match &answers {
-            Some(answers) => asked
-                .iter()
-                .filter_map(|question| answers.get(question))
-                .map(|items| match items {
-                    Value::Array(items) => items.iter().filter_map(Value::as_str).collect::<Vec<_>>().join(", "),
-                    item => item.as_str().unwrap_or_default().to_owned(),
-                })
-                .collect::<Vec<_>>()
-                .join("; "),
-            None => answer
-                .as_ref()
-                .and_then(|reply| options.iter().find(|option| &option.id == reply))
-                .map_or_else(|| "Cancelled".to_owned(), |option| option.name.clone()),
-        };
+        let name = answer
+            .as_ref()
+            .and_then(|a| options.iter().find(|o| &o.id == a))
+            .map_or_else(|| "Cancelled".to_owned(), |o| o.name.clone());
        {
            let mut s = self.state.lock();
            if let Some(AgentEntry::Permission { chosen, .. }) = s.conversation.main.entries.get_mut(entry) {
@@ -1824,31 +1558,6 @@ impl Task {
        if !still_asking && self.state.lock().task.status == AgentStatus::NeedsInput {
            self.set_status(AgentStatus::Running, None);
        }
-        // An agent that answers by index reads the answers beside the outcome, keyed by
-        // question index, with its Submit option chosen; anything less cancels the request.
-        if by_index {
-            let submit = options.iter().find(|option| option.kind == "allow_once").or_else(|| options.first());
-            return match (answers.as_ref(), submit) {
-                (Some(answers), Some(submit)) => {
-                    let picked: serde_json::Map<String, Value> = asked
-                        .iter()
-                        .enumerate()
-                        .filter_map(|(index, question)| {
-                            let items = answers.get(question)?;
-                            let answer = match items {
-                                Value::Array(items) => {
-                                    items.iter().filter_map(Value::as_str).collect::<Vec<_>>().join(", ")
-                                }
-                                item => item.as_str().unwrap_or_default().to_owned(),
-                            };
-                            Some((index.to_string(), json!(answer)))
-                        })
-                        .collect();
-                    json!({ "outcome": { "outcome": "selected", "optionId": submit.id }, "answers": picked })
-                }
-                _ => json!({ "outcome": { "outcome": "cancelled" } }),
-            };
-        }
        match answer {
            Some(option) => json!({ "outcome": { "outcome": "selected", "optionId": option } }),
            None => json!({ "outcome": { "outcome": "cancelled" } }),
@@ -1862,10 +1571,7 @@ impl Task {
        }
        let mut pending = self.permissions.lock();
        for entry in s.conversation.main.entries.iter().rev() {
-            // A request with questions is never satisfied by a bypass: its Submit option
-            // would answer with no answers.
-            if let AgentEntry::Permission { id, options, questions, chosen: None, .. } = entry
-                && questions.is_empty()
+            if let AgentEntry::Permission { id, options, chosen: None, .. } = entry
                && let Some(option) = options.iter().find(|o| o.kind == "allow_once")
                && let Some(reply) = pending.remove(id)
            {
@@ -1891,13 +1597,11 @@ impl Task {
        }
    }

-    /// Stops the agent; returns its connection, to wait for its process to exit.
-    fn kill(&self) -> Option<acp::Conn> {
+    fn kill(&self) {
        self.cancel_permissions();
-        let live = self.live.lock().take()?;
-        live.peer.kill();
-        self.clear_shown_background();
-        Some(live.peer)
+        if let Some(live) = self.live.lock().take() {
+            live.peer.kill();
+        }
    }
 }

@@ -1930,82 +1634,6 @@ fn clean(mut prompt: AgentPrompt) -> Option<AgentPrompt> {
    (!prompt.text.is_empty() || !prompt.images.is_empty() || !prompt.files.is_empty()).then_some(prompt)
 }

-fn permission_title(params: &Value) -> String {
-    let call = &params["toolCall"];
-    let title = call.get("title").and_then(Value::as_str).filter(|t| !t.is_empty());
-    if call.get("kind").and_then(Value::as_str) == Some("execute") {
-        if let Some(command) = call.pointer("/rawInput/command").and_then(Value::as_str).filter(|c| !c.is_empty()) {
-            // Network approvals describe the host rather than approving command execution.
-            if !title.is_some_and(|t| t.starts_with("Allow network access to ")) {
-                return format!("Run {}", shell_script(command).unwrap_or_else(|| command.to_owned()));
-            }
-        }
-        if title.is_none()
-            && let Some(content) = call.get("content").and_then(Value::as_array)
-            && let Some(text) = content.iter().find_map(|c| c.pointer("/content/text").and_then(Value::as_str))
-        {
-            return format!("Run {text}");
-        }
-    }
-    title.unwrap_or("The agent asks for permission").to_owned()
-}
-
-/// The script of a `<shell> -c <quoted script>` command line, when the whole line is exactly that.
-pub(crate) fn shell_script(command: &str) -> Option<String> {
-    let (shell, rest) = command.split_once(' ')?;
-    if !matches!(shell.rsplit('/').next(), Some("sh" | "bash" | "zsh")) {
-        return None;
-    }
-    let quoted = rest.strip_prefix("-lc ").or_else(|| rest.strip_prefix("-c "))?;
-    let mut out = String::new();
-    let mut chars = quoted.chars();
-    // Adjacent quoted words, e.g. 'a'\''b' or "a \"b\"".
-    while let Some(c) = chars.next() {
-        match c {
-            '\'' => loop {
-                match chars.next()? {
-                    '\'' => break,
-                    c => out.push(c),
-                }
-            },
-            '"' => loop {
-                match chars.next()? {
-                    '"' => break,
-                    '\\' => match chars.next()? {
-                        c @ ('"' | '\\' | '$' | '`') => out.push(c),
-                        '\n' => {}
-                        c => {
-                            out.push('\\');
-                            out.push(c);
-                        }
-                    },
-                    c => out.push(c),
-                }
-            },
-            '\\' => out.push(chars.next()?),
-            _ => return None,
-        }
-    }
-    Some(out)
-}
-
-/// The questions a permission request asks, and whether they answer by question index.
-/// The Claude Code adapter carries them as `_meta.questions`, answered as the option id;
-/// Qwen Code (ACP) as `_meta.qwenQuestions`, answered with `answers` keyed by index beside
-/// the id of its Submit option.
-fn asked_questions(params: &Value) -> (Vec<AgentQuestion>, bool) {
-    for (pointer, by_index) in [("/toolCall/_meta/questions", false), ("/toolCall/_meta/qwenQuestions", true)] {
-        if let Some(questions) = params
-            .pointer(pointer)
-            .and_then(|questions| serde_json::from_value::<Vec<AgentQuestion>>(questions.clone()).ok())
-            .filter(|questions| !questions.is_empty())
-        {
-            return (questions, by_index);
-        }
-    }
-    (Vec::new(), false)
-}
-
 /// ACP content blocks: the text, each file (embedded when its text is in `contents`, else
 /// a `resource_link`), then the images.
 fn blocks(prompt: &AgentPrompt, contents: &[Option<String>]) -> Vec<Value> {
@@ -2086,19 +1714,6 @@ fn client_info() -> Value {
 }

 /// What the agent said it can do, and whether it takes embedded files.
-fn shown_background(tasks: &[Value], known: &[AgentBackgroundTask]) -> Vec<AgentBackgroundTask> {
-    let now = now_ms();
-    tasks
-        .iter()
-        .filter_map(|task| {
-            let id = task.get("task_id")?.as_str()?.to_owned();
-            let started_ms = known.iter().find(|seen| seen.id == id).map_or(now, |seen| seen.started_ms);
-            let text = |key: &str| task.get(key).and_then(Value::as_str).unwrap_or_default().to_owned();
-            Some(AgentBackgroundTask { id, kind: text("task_type"), description: text("description"), started_ms })
-        })
-        .collect()
-}
-
 fn capabilities_of(init: &acp::Negotiated) -> (AgentCapabilities, bool) {
    let meta = |p: &str| init.meta(p).and_then(Value::as_bool) == Some(true);
    let capabilities = AgentCapabilities {
@@ -2106,7 +1721,6 @@ fn capabilities_of(init: &acp::Negotiated) -> (AgentCapabilities, bool) {
        fork: init.session("fork"),
        rollback: meta("/openidea/rollback"),
        steer: meta("/openidea/steer"),
-        background_tasks: meta("/openidea/backgroundTasks"),
    };
    (capabilities, init.prompt("embeddedContext"))
 }
@@ -2121,10 +1735,6 @@ fn turn_starts(entries: &[AgentEntry]) -> Vec<usize> {
        .collect()
 }

-fn is_false(b: &bool) -> bool {
-    !*b
-}
-
 fn is_zero(n: &u32) -> bool {
    *n == 0
 }
@@ -3,7 +3,6 @@
 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")]
@@ -34,8 +33,6 @@ pub struct AgentCapabilities {
    pub rollback: bool,
    /// A message can join the running turn instead of waiting for it.
    pub steer: bool,
-    /// It reports its background tasks and stops them one by one.
-    pub background_tasks: bool,
 }

 #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
@@ -91,22 +88,6 @@ pub struct AgentTask {
    /// by its next output or any status change.
    #[serde(default)]
    pub retry: Option<AgentRetry>,
-    /// What the agent runs in the background (shells, subagents, monitors), oldest first.
-    // Boxed so that `AgentEvent::Task` stays within clippy's `large_enum_variant` bound on Windows.
-    #[serde(default)]
-    pub background: Box<Vec<AgentBackgroundTask>>,
-}
-
-/// A task the agent runs in the background while the conversation goes on.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub struct AgentBackgroundTask {
-    pub id: String,
-    /// What it is, as the agent names it (`local_bash`, `local_agent`, `monitor`…).
-    pub kind: String,
-    pub description: String,
-    /// When the client first saw it (ms since the epoch).
-    pub started_ms: f64,
 }

 /// An API request the agent is about to retry.
@@ -278,31 +259,6 @@ pub struct AgentPermissionOption {
    pub kind: String,
 }

-/// A question the agent asks with `AskUserQuestion`, answered by picking options or typing.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub struct AgentQuestion {
-    /// Stable answer identity when the provider supplies question ids.
-    #[serde(default)]
-    pub answer_key: Option<String>,
-    #[serde(default)]
-    pub header: String,
-    pub question: String,
-    #[serde(default)]
-    pub multi_select: bool,
-    pub options: Vec<AgentQuestionOption>,
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub struct AgentQuestionOption {
-    pub label: String,
-    #[serde(default)]
-    pub description: String,
-    #[serde(default)]
-    pub preview: Option<String>,
-}
-
 /// One item of a task's conversation.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
 #[serde(tag = "type", rename_all = "camelCase", rename_all_fields = "camelCase")]
@@ -375,10 +331,6 @@ pub enum AgentEntry {
        id: u32,
        title: String,
        options: Vec<AgentPermissionOption>,
-        /// Set when the request asks `AskUserQuestion`'s questions; answered with a JSON object
-        /// of question to answer instead of an option.
-        #[serde(default)]
-        questions: Vec<AgentQuestion>,
        /// Name of the chosen option, or `None` while pending. Cancelled requests read "Cancelled".
        chosen: Option<String>,
    },
@@ -405,13 +357,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>,
-    /// Thinking-level options by model value; absent models have not reported their levels.
-    #[serde(default)]
-    pub thought_levels: BTreeMap<String, Vec<AgentConfigOption>>,
    /// Slash commands it offered last time.
    pub commands: Vec<AgentCommand>,
    pub source: AgentSource,
@@ -312,7 +312,7 @@ impl Shim {
                        "loadSession": true,
                        "promptCapabilities": { "image": true, "embeddedContext": true },
                        "sessionCapabilities": { "fork": {} },
-                        "_meta": { "openidea": { "rollback": true, "steer": true, "backgroundTasks": true } },
+                        "_meta": { "openidea": { "rollback": true, "steer": true } },
                    },
                    "agentInfo": { "name": "claude", "title": "Claude Code", "version": self.version() },
                    "authMethods": [],
@@ -396,13 +396,6 @@ impl Shim {
                session.steer(params.get("prompt").cloned().unwrap_or_default()).map_err(invalid)?;
                Ok(json!({}))
            }
-            "_openidea/stop_task" => {
-                let session = self.session(&params)?;
-                let task = params.get("taskId").and_then(Value::as_str).ok_or_else(|| invalid("no taskId"))?;
-                let proc = session.st.lock().proc.clone().ok_or_else(|| internal("Claude Code is not running"))?;
-                rt.block_on(proc.control(json!({ "subtype": "stop_task", "task_id": task }))).map_err(internal)?;
-                Ok(json!({}))
-            }
            "_openidea/rollback" => {
                let session = self.session(&params)?;
                let turns = params.get("turns").and_then(Value::as_u64).unwrap_or(0) as usize;
@@ -618,8 +611,7 @@ impl Session {
                session.on_exit(&reader_proc);
            }
        });
-        // Stop ends the turn only: the client stops background tasks one by one.
-        let init = proc.control(json!({ "subtype": "initialize", "perTaskStopAffordance": true })).await?;
+        let init = proc.control(json!({ "subtype": "initialize" })).await?;
        let applied = proc.control(json!({ "subtype": "get_settings" })).await.unwrap_or_default();
        let chosen = {
            let mut st = self.st.lock();
@@ -1117,46 +1109,38 @@ fn permission_result(
    }
 }

-/// `AskUserQuestion`: one permission request carrying all its questions, answered with a
-/// JSON object of question to the chosen labels and typed text; `None` when skipped.
+/// `AskUserQuestion`: each question as a permission request whose options are its
+/// answers; `None` when one is not answered.
 async fn ask_questions<F, Fut>(input: &Value, call: &Value, ask: F) -> Option<Value>
 where
    F: Fn(Value, Value) -> Fut,
    Fut: std::future::Future<Output = Option<String>>,
 {
-    let questions = input.get("questions")?;
-    let mut call = call.clone();
-    call["title"] = questions.pointer("/0/question").cloned().unwrap_or_else(|| json!("Claude has a question"));
-    call["_meta"] = json!({ "questions": questions });
-    let options = json!([{ "optionId": "reject", "name": "Skip", "kind": "reject_once" }]);
-    let chosen = ask(call, options).await?;
-    let chosen: serde_json::Map<String, Value> = serde_json::from_str(&chosen).ok()?;
-    let answers = questions
-        .as_array()?
-        .iter()
-        .filter_map(|entry| {
-            let question = entry.get("question")?.as_str()?;
-            let items: Vec<&str> = chosen.get(question)?.as_array()?.iter().filter_map(Value::as_str).collect();
-            let multi = entry.get("multiSelect").and_then(Value::as_bool) == Some(true);
-            let answer = if multi { join_answers(&items) } else { items.first()?.to_string() };
-            Some((question.to_owned(), json!(answer)))
-        })
-        .collect();
+    let mut answers = serde_json::Map::new();
+    for q in input.get("questions").and_then(Value::as_array).into_iter().flatten() {
+        let question = q.get("question").and_then(Value::as_str).unwrap_or_default();
+        let labels: Vec<&str> = q
+            .get("options")
+            .and_then(Value::as_array)
+            .into_iter()
+            .flatten()
+            .filter_map(|o| o.get("label")?.as_str())
+            .collect();
+        let mut options: Vec<Value> = labels
+            .iter()
+            .enumerate()
+            .map(|(i, l)| json!({ "optionId": format!("answer-{i}"), "name": l, "kind": "allow_once" }))
+            .collect();
+        options.push(json!({ "optionId": "reject", "name": "Skip", "kind": "reject_once" }));
+        let mut call = call.clone();
+        call["title"] = json!(question);
+        let chosen = ask(call, Value::Array(options)).await?;
+        let i: usize = chosen.strip_prefix("answer-")?.parse().ok()?;
+        answers.insert(question.to_owned(), json!(labels.get(i)?));
+    }
    Some(Value::Object(answers))
 }

-/// A multi-select answer as Claude Code's own question UI writes it: comma-joined, with an
-/// item that holds the separator or a quote JSON-quoted so it reads back as one item.
-fn join_answers(items: &[&str]) -> String {
-    items
-        .iter()
-        .map(
-            |item| if item.contains(", ") || item.contains('"') { json!(item).to_string() } else { (*item).to_owned() },
-        )
-        .collect::<Vec<_>>()
-        .join(", ")
-}
-
 /// Whether `result` ends `turn`: it answers the turn's last message, or (stopped) any of
 /// its messages, or names none (the CLI's own error before the turn began).
 fn belongs(turn: &Turn, result: &Value) -> bool {
@@ -976,19 +976,6 @@ fn api_retries_are_announced() {
    );
 }

-#[test]
-fn background_tasks_are_announced_wholesale() {
-    let mut t = Translator::new("s", PathBuf::from("/w"), true);
-    let tasks = json!([{"task_id": "bsh1", "task_type": "local_bash", "description": "sleep 900"}]);
-    let out = t.on_message(&json!({"type": "system", "subtype": "background_tasks_changed", "tasks": tasks}));
-    assert_eq!(out.len(), 1);
-    assert_eq!(out[0].session, "s");
-    assert_eq!(out[0].update, json!({"sessionUpdate": crate::BACKGROUND_TASKS_UPDATE, "tasks": tasks}));
-    // The list is replaced with every report: an empty one says every task is done.
-    let out = t.on_message(&json!({"type": "system", "subtype": "background_tasks_changed", "tasks": []}));
-    assert_eq!(out[0].update, json!({"sessionUpdate": crate::BACKGROUND_TASKS_UPDATE, "tasks": []}));
-}
-
 #[test]
 fn streamed_text_is_not_sent_twice() {
    let mut t = Translator::new("s", PathBuf::from("/w"), true);
@@ -1106,67 +1093,3 @@ fn tool_calls_plans_and_subagents() {
    assert_eq!(finished[1].update["content"][0]["text"], "It is x");
    assert_eq!(finished[1].update["senderSessionId"], "ag");
 }
-
-#[tokio::test]
-async fn questions_go_out_as_one_request() {
-    let questions = json!([
-        {"header": "Files", "question": "Where should they live?", "multiSelect": false,
-         "options": [{"label": "Local", "description": "Kept out of git"}, {"label": "Committed", "description": "In the repo"}]},
-        {"header": "Checks", "question": "Which checks?", "multiSelect": true,
-         "options": [{"label": "Lint", "description": ""}, {"label": "Tests", "description": ""}]},
-    ]);
-    let input = json!({ "questions": questions });
-    let asked = std::sync::Mutex::new(Vec::new());
-    let reply = json!({"Where should they live?": ["Local"], "Which checks?": ["Lint", "Tests"]}).to_string();
-    let answers = json!({"Where should they live?": "Local", "Which checks?": "Lint, Tests"});
-    let result = ask_questions(&input, &json!({"toolCallId": "t"}), |call, options| {
-        asked.lock().unwrap().push((call, options));
-        let reply = reply.clone();
-        async move { Some(reply) }
-    })
-    .await;
-    assert_eq!(result, Some(answers));
-    let asked = asked.into_inner().unwrap();
-    assert_eq!(asked.len(), 1);
-    let (call, options) = &asked[0];
-    assert_eq!(call["title"], "Where should they live?");
-    assert_eq!(call["_meta"]["questions"], questions);
-    assert_eq!(options[0]["optionId"], "reject");
-}
-
-#[tokio::test]
-async fn answers_keep_claude_codes_format_with_other_text() {
-    let input = json!({"questions": [
-        {"question": "Which cache?", "multiSelect": false, "options": [{"label": "Redis"}, {"label": "None"}]},
-        {"question": "Which checks?", "multiSelect": true, "options": [{"label": "Lint"}, {"label": "Tests"}]},
-        {"question": "Which stores?", "multiSelect": true, "options": [{"label": "Disk"}, {"label": "S3"}]},
-    ]});
-    let reply = json!({
-        "Which cache?": ["Memcached, for now"],
-        "Which checks?": ["Lint", "Tests"],
-        "Which stores?": ["Disk", "Redis, not Memcached", "a \"cold\" tier"],
-    })
-    .to_string();
-    let result = ask_questions(&input, &json!({}), |_, _| {
-        let reply = reply.clone();
-        async move { Some(reply) }
-    })
-    .await;
-    assert_eq!(
-        result,
-        Some(json!({
-            "Which cache?": "Memcached, for now",
-            "Which checks?": "Lint, Tests",
-            "Which stores?": "Disk, \"Redis, not Memcached\", \"a \\\"cold\\\" tier\"",
-        }))
-    );
-}
-
-#[tokio::test]
-async fn skipped_questions_have_no_answers() {
-    let input = json!({"questions": [{"question": "Which?", "options": [{"label": "A"}]}]});
-    let skipped = ask_questions(&input, &json!({}), |_, _| async { Some("reject".to_owned()) }).await;
-    assert_eq!(skipped, None);
-    let cancelled = ask_questions(&input, &json!({}), |_, _| async { None }).await;
-    assert_eq!(cancelled, None);
-}
@@ -5,7 +5,7 @@
 //! Agent tool use that launched them: their messages carry it as `parent_tool_use_id`.

 use super::tools;
-use crate::{BACKGROUND_TASKS_UPDATE, LIMITS_UPDATE, RETRY_UPDATE};
+use crate::{LIMITS_UPDATE, RETRY_UPDATE};
 use serde_json::{Value, json};
 use std::collections::{HashMap, VecDeque};
 use std::path::PathBuf;
@@ -458,15 +458,6 @@ impl Translator {
                let last = self.children.get(&tool_use).map(|c| c.last_text.clone()).filter(|t| !t.is_empty());
                self.finish_child(&tool_use, stop, last.or(summary))
            }
-            // A turn's background tasks (`run_in_background`) outlive it: the task keeps
-            // the list and stays up while it isn't empty (see `Task::release_when_idle`).
-            Some("background_tasks_changed") => {
-                let Some(tasks) = msg.get("tasks").and_then(Value::as_array).cloned() else { return Vec::new() };
-                vec![Update {
-                    session: self.root.clone(),
-                    update: json!({ "sessionUpdate": BACKGROUND_TASKS_UPDATE, "tasks": tasks }),
-                }]
-            }
            _ => Vec::new(),
        }
    }
@@ -822,7 +822,7 @@ impl CodexShim {
        match method {
            "item/commandExecution/requestApproval" => {
                let choices = translate::decisions(params, true);
-                let title = translate::command_approval_title(params, item.as_ref());
+                let title = translate::command_approval_title(params, item.as_ref(), cwd);
                let call = tool_call_of(
                    &item_id,
                    &title,
@@ -871,55 +871,31 @@ impl CodexShim {
                Ok(self.ask(&thread, call, &choices, json!({ "permissions": {}, "scope": "turn" })))
            }
            "item/tool/requestUserInput" => {
-                let questions = params.get("questions").and_then(Value::as_array).cloned().unwrap_or_default();
-                // One permission request carrying all the questions, so the client shows
-                // them as a card (as it does for Claude's `AskUserQuestion`).
-                let asked: Vec<Value> = questions
-                    .iter()
-                    .filter_map(|q| {
-                        let id = q.get("id").and_then(Value::as_str)?;
-                        let question = q.get("question").and_then(Value::as_str)?;
-                        let options: Vec<Value> = q
-                            .get("options")
-                            .and_then(Value::as_array)
-                            .into_iter()
-                            .flatten()
-                            .filter_map(|o| {
-                                let label = o.get("label").and_then(Value::as_str)?;
-                                Some(json!({
-                                    "label": label,
-                                    "description": o.get("description").and_then(Value::as_str).unwrap_or_default(),
-                                }))
-                            })
-                            .collect();
-                        Some(json!({
-                            "answerKey": id,
-                            "header": q.get("header").and_then(Value::as_str).unwrap_or_default(),
-                            "question": question,
-                            "multiSelect": q.get("multiSelect").and_then(Value::as_bool).unwrap_or(false),
-                            "options": options,
-                        }))
-                    })
-                    .collect();
-                if asked.is_empty() {
-                    return Ok(json!({ "answers": {} }));
-                }
-                let title = asked[0].get("question").and_then(Value::as_str).unwrap_or("Codex has a question");
-                let mut call = tool_call_of(&item_id, title, "other", None, None);
-                call["_meta"] = json!({ "questions": asked });
-                let options = [json!({ "optionId": "submit", "name": "Submit", "kind": "allow_once" })];
-                let picked: serde_json::Map<String, Value> = self
-                    .ask_option(&thread, call, &options)
-                    .and_then(|reply| serde_json::from_str(&reply).ok())
-                    .unwrap_or_default();
                let mut answers = serde_json::Map::new();
-                for q in &questions {
+                for q in params.get("questions").and_then(Value::as_array).into_iter().flatten() {
                    let Some(qid) = q.get("id").and_then(Value::as_str) else { continue };
-                    if let Some(labels) = picked
-                        .get(qid)
-                        .filter(|labels| labels.as_array().is_some_and(|labels| labels.iter().all(Value::is_string)))
-                    {
-                        answers.insert(qid.to_owned(), json!({ "answers": labels }));
+                    let choices: Vec<Choice> = q
+                        .get("options")
+                        .and_then(Value::as_array)
+                        .into_iter()
+                        .flatten()
+                        .enumerate()
+                        .filter_map(|(i, o)| {
+                            let label = o.get("label")?.as_str()?;
+                            Some(Choice {
+                                option: json!({ "optionId": i.to_string(), "name": label, "kind": "allow_once" }),
+                                answer: json!({ "answers": [label] }),
+                            })
+                        })
+                        .collect();
+                    if choices.is_empty() {
+                        continue;
+                    }
+                    let title = q.get("question").and_then(Value::as_str).unwrap_or("Codex has a question");
+                    let call = tool_call_of(&item_id, title, "other", None, None);
+                    let answer = self.ask(&thread, call, &choices, Value::Null);
+                    if !answer.is_null() {
+                        answers.insert(qid.to_owned(), answer);
                    }
                }
                Ok(json!({ "answers": answers }))
@@ -952,25 +928,6 @@ impl CodexShim {
        }
    }

-    /// Asks the client; returns the selected option id (`None` when cancelled).
-    fn ask_option(&self, session: &str, tool_call: Value, options: &[Value]) -> Option<String> {
-        let client = self.client.get().cloned()?;
-        let params = json!({ "sessionId": session, "toolCall": tool_call, "options": options });
-        let outcome: Result<Value, RpcError> =
-            self.runtime.block_on(client.request("session/request_permission", params, None));
-        match outcome {
-            Ok(outcome) => outcome
-                .pointer("/outcome/outcome")
-                .and_then(Value::as_str)
-                .filter(|outcome| *outcome == "selected")
-                .and_then(|_| outcome.pointer("/outcome/optionId").and_then(Value::as_str).map(str::to_owned)),
-            Err(e) => {
-                tracing::debug!("codex: question request failed: {e}");
-                None
-            }
-        }
-    }
-
    /// Asks the client; returns the answer for codex (`otherwise` when cancelled).
    fn ask(&self, session: &str, tool_call: Value, choices: &[Choice], otherwise: Value) -> Value {
        let Some(client) = self.client.get().cloned() else { return otherwise };
@@ -247,39 +247,13 @@ fn approvals_offer_what_codex_offers_and_always_a_decline() {
    assert_eq!(
        command_approval_title(
            &json!({"command": "/bin/zsh -lc 'ls'", "commandActions": [{"type": "unknown", "command": "touch b"}]}),
+            None,
            None
        ),
-        "Run ls"
+        "Run touch b"
    );
 }

-#[test]
-fn approval_title_shows_the_script_inside_a_shell_wrapper() {
-    let title = |command: &str| command_approval_title(&json!({ "command": command }), None);
-    assert_eq!(
-        title(r#"/bin/zsh -lc "python3 -c 'import pathlib\np = pathlib.Path(\"a.txt\")'""#),
-        "Run python3 -c 'import pathlib\\np = pathlib.Path(\"a.txt\")'"
-    );
-    assert_eq!(title(r#"bash -lc 'echo '\''hi'\'''"#), "Run echo 'hi'");
-    assert_eq!(title("/bin/zsh -lc ls"), "Run /bin/zsh -lc ls");
-    assert_eq!(title("/bin/zsh -lc 'ls' && rm x"), "Run /bin/zsh -lc 'ls' && rm x");
-    assert_eq!(title("python3 -c 'print(1)'"), "Run python3 -c 'print(1)'");
-}
-
-#[test]
-fn approval_command_uses_its_request_and_matching_item_only() {
-    let command = "python3 -c 'import pathlib\np = pathlib.Path(\"note.txt\")\np.write_text(\"hi\\n\")'";
-    let pending_read = json!({"id": "read", "type": "commandExecution", "command": "ls",
-        "commandActions": [{"type": "listFiles", "path": "."}]});
-    let request = json!({"itemId": "write", "command": command});
-    assert_eq!(command_approval_title(&request, Some(&pending_read)), format!("Run {command}"));
-    let item = json!({"id": "write", "command": command});
-    let request = json!({"itemId": "write"});
-    assert_eq!(command_approval_title(&request, Some(&item)), format!("Run {command}"));
-    assert_eq!(command_approval_title(&request, Some(&pending_read)), "Run a command");
-    assert_eq!(command_approval_title(&request, None), "Run a command");
-}
-
 #[test]
 fn history_replays_turns() {
    let thread = json!({"turns": [{"id": "t", "status": "completed", "items": [
@@ -342,39 +316,6 @@ impl Client {
    }
 }

-#[tokio::test(flavor = "multi_thread")]
-async fn questions_share_one_card_and_keep_their_ids() {
-    let client = Arc::new(Client::default());
-    client.answers.lock().extend([Some(r#"{"first":["One"],"second":["Two","Custom"]}"#), None, Some("invalid")]);
-    let (ours, theirs) = tokio::io::duplex(1 << 16);
-    let (read, write) = tokio::io::split(theirs);
-    let codex = Peer::connect_framed(read, write, Arc::new(ide_jsonrpc::NoopHandler), Framing::Lines);
-    let acp = attach(client.clone(), |events| {
-        let (read, write) = tokio::io::split(ours);
-        Ok(Peer::connect_framed(read, write, events, Framing::Lines))
-    })
-    .unwrap();
-    let params = json!({"threadId": "s", "itemId": "q", "questions": [
-        {"id": "first", "question": "Which?", "options": [{"label": "One", "description": "First"}]},
-        {"id": "second", "question": "Which?", "multiSelect": true, "options": [{"label": "Two"}]}
-    ]});
-    for expected in
-        [json!({"first": {"answers": ["One"]}, "second": {"answers": ["Two", "Custom"]}}), json!({}), json!({})]
-    {
-        let reply: Value = codex.request("item/tool/requestUserInput", params.clone(), None).await.unwrap();
-        assert_eq!(reply, json!({"answers": expected}));
-    }
-    let asked = client.asked.lock();
-    assert_eq!(asked.len(), 3);
-    let questions = &asked[0]["toolCall"]["_meta"]["questions"];
-    assert_eq!(questions.as_array().unwrap().len(), 2);
-    assert_eq!(questions[0]["answerKey"], "first");
-    assert_eq!(questions[1]["answerKey"], "second");
-    assert_eq!(questions[0]["options"][0]["description"], "First");
-    acp.kill();
-    codex.kill();
-}
-
 #[derive(Clone, Copy, Debug, PartialEq)]
 enum Scenario {
    AuthFailure,
@@ -733,19 +733,18 @@ pub(super) fn answer_of(choices: &[Choice], outcome: &Value, decline: Value) ->
 }

 /// The ACP title of a command approval.
-pub(super) fn command_approval_title(params: &Value, item: Option<&Value>) -> String {
+pub(super) fn command_approval_title(params: &Value, item: Option<&Value>, cwd: Option<&str>) -> String {
    if let Some(host) = params.pointer("/networkApprovalContext/host").and_then(Value::as_str) {
        return format!("Allow network access to {host}");
    }
-    // Approval payloads can describe a different command from the item's earlier summary.
-    let item = item.filter(|i| i.get("id") == params.get("itemId"));
-    let command = params
-        .get("command")
-        .and_then(Value::as_str)
-        .filter(|c| !c.is_empty())
-        .or_else(|| item.and_then(|i| i.get("command")).and_then(Value::as_str).filter(|c| !c.is_empty()));
-    match command {
-        Some(command) => format!("Run {}", crate::shell_script(command).unwrap_or_else(|| command.to_owned())),
+    let from_item = item.and_then(|i| tool_call(i, false, cwd, None)).and_then(|c| str_of(&c, "title"));
+    let title = from_item.or_else(|| {
+        let synthetic = json!({ "id": "", "type": "commandExecution", "command": params.get("command"),
+            "commandActions": params.get("commandActions").cloned().unwrap_or(json!([])) });
+        tool_call(&synthetic, false, cwd, None).and_then(|c| str_of(&c, "title"))
+    });
+    match title.filter(|t| !t.is_empty()) {
+        Some(t) => format!("Run {t}"),
        None => "Run a command".to_owned(),
    }
 }
@@ -81,64 +81,6 @@ fn builtins() -> Vec<ProviderSpec> {
        .collect()
 }

-impl ProviderSpec {
-    pub(crate) fn login_hint(&self, program: &Path) -> String {
-        if !program.is_absolute() {
-            return self.login_hint.clone();
-        }
-        let search = ide_core::process::host_var_os("PATH").unwrap_or_default();
-        let builtin = builtin_spec(&self.id);
-        let on_path = builtin.as_ref().and_then(|b| ide_core::process::find_executable(&b.command, &search));
-        render_login_hint(self, program, on_path.as_deref(), cfg!(windows))
-    }
-
-    pub(crate) fn sign_in_message(&self) -> String {
-        let name = &self.name;
-        let hint = self.login_hint(Path::new(&self.command));
-        format!("{name} needs you to sign in. {hint}")
-    }
-
-    /// Resolve once before connecting, so authentication guidance names that same install.
-    pub(crate) fn resolve_for_launch(mut self, cwd: &Path) -> Self {
-        if self.driver != Driver::Acp {
-            self.command = crate::native::newest_install(&self.command);
-        }
-        let program = ide_jsonrpc::resolve_spawn_program(&self.command, &self.env);
-        self.command =
-            if program.components().count() > 1 && !program.is_absolute() { cwd.join(program) } else { program }
-                .to_string_lossy()
-                .into_owned();
-        self
-    }
-}
-
-fn render_login_hint(spec: &ProviderSpec, program: &Path, on_path: Option<&Path>, windows: bool) -> String {
-    let Some(builtin) = builtin_spec(&spec.id) else { return spec.login_hint.clone() };
-    let prefix = format!("Run `{}", builtin.command);
-    let Some(rest) = spec.login_hint.strip_prefix(&prefix).filter(|rest| rest.starts_with([' ', '`'])) else {
-        return spec.login_hint.clone();
-    };
-    let same_path = |a: &Path, b: &Path| {
-        a == b || dunce::canonicalize(a).ok().zip(dunce::canonicalize(b).ok()).is_some_and(|(a, b)| a == b)
-    };
-    if on_path.is_some_and(|path| same_path(path, program)) {
-        return spec.login_hint.clone();
-    }
-    let path = program.to_string_lossy();
-    let quoted = if windows {
-        format!("& '{}'", path.replace('\'', "''"))
-    } else {
-        format!("'{}'", path.replace('\'', "'\\''"))
-    };
-    let (args, suffix) = rest.split_once('`').expect("built-in login hints delimit their command");
-    let command = format!("{quoted}{args}");
-    match suffix {
-        " in a terminal." => format!("Run `{command}` in a terminal."),
-        " in a terminal and sign in." => format!("Run `{command}` in a terminal and sign in."),
-        _ => spec.login_hint.clone(),
-    }
-}
-
 /// Whether `id` names a built-in agent that needs no registry install (native drivers
 /// and `npx -y` adapters). CLI built-ins (`copilot`, `gemini`, …) can be installed and
 /// updated from the ACP Registry into `<config>/agents/<id>.toml`.
@@ -177,14 +119,12 @@ pub(crate) fn describe(spec: &ProviderSpec) -> AgentProvider {
        args: spec.args.clone(),
        default_program: builtin.as_ref().map(|b| b.command.clone()),
        default_args: builtin.as_ref().map(|b| b.args.clone()).unwrap_or_default(),
-        login_hint: Some(spec.login_hint(&ide_jsonrpc::resolve_spawn_program(&spec.command, &spec.env))),
+        login_hint: Some(spec.login_hint.clone()),
        command_overridden: builtin.as_ref().is_some_and(|b| b.command != spec.command),
        command_editable: reason.is_none(),
        command_read_only_reason: reason,
        installed: installed(&spec.command),
-        env: spec.env.iter().cloned().collect(),
        config: vec![],
-        thought_levels: BTreeMap::new(),
        commands: vec![],
        source: spec.source.clone(),
    }
@@ -193,16 +133,6 @@ 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")));
    };
@@ -222,8 +152,7 @@ fn update_builtin(custom_dir: &Path, id: &str, change: impl FnOnce(&mut CustomAg
    if agent.registry.is_some() {
        return Err(IdeError::invalid(format!("{id} is installed from the ACP Registry")));
    }
-    change(&mut agent, &builtin);
-    if agent.command == builtin.command
+    if command.is_none()
        && agent.name.as_deref() == Some(builtin.name.as_str())
        && agent.driver == builtin.driver
        && agent.args == builtin.args
@@ -235,6 +164,7 @@ fn update_builtin(custom_dir: &Path, id: &str, change: impl FnOnce(&mut CustomAg
        }
        return Ok(());
    }
+    agent.command = command.unwrap_or(&builtin.command).to_owned();
    agent.write(&file)?;
    Ok(())
 }
@@ -371,81 +301,6 @@ fn is_executable(p: &Path) -> bool {
 mod tests {
    use super::*;

-    #[test]
-    fn login_hints_cover_all_builtin_commands_and_preserve_separate_login_tools() {
-        for spec in builtins() {
-            let separate = matches!(spec.id.as_str(), "claude-acp" | "codex-acp" | "vibe");
-            for windows in [false, true] {
-                let program =
-                    if windows { Path::new(r"C:\Agent Tools\renamed.cmd") } else { Path::new("/agent tools/renamed") };
-                let hint = render_login_hint(&spec, program, None, windows);
-                if separate {
-                    assert_eq!(hint, spec.login_hint, "{}", spec.id);
-                } else {
-                    let prefix =
-                        if windows { "Run `& 'C:\\Agent Tools\\renamed.cmd'" } else { "Run `'/agent tools/renamed'" };
-                    assert!(hint.starts_with(prefix), "{}: {hint}", spec.id);
-                    assert_eq!(
-                        render_login_hint(&spec, program, Some(program), windows),
-                        spec.login_hint,
-                        "a PATH-resolved command stays bare: {}",
-                        spec.id
-                    );
-                    assert_eq!(render_login_hint(&spec, program, Some(Path::new("/other/install")), windows), hint);
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn login_commands_quote_shell_metacharacters_and_keep_arguments() {
-        let cursor = builtin_spec("cursor").unwrap();
-        assert_eq!(
-            render_login_hint(&cursor, Path::new("/agent's tools/$cli"), None, false),
-            "Run `'/agent'\\''s tools/$cli' login` in a terminal."
-        );
-        assert_eq!(
-            render_login_hint(&cursor, Path::new(r"C:\agent's tools\$cli.cmd"), None, true),
-            r"Run `& 'C:\agent''s tools\$cli.cmd' login` in a terminal."
-        );
-        let opencode = builtin_spec("opencode").unwrap();
-        assert_eq!(
-            render_login_hint(&opencode, Path::new("/registry/opencode"), None, false),
-            "Run `'/registry/opencode' auth login` in a terminal."
-        );
-        let mut custom = cursor;
-        custom.id = "custom".into();
-        custom.login_hint = "Sign in with the agent's own command line first.".into();
-        assert_eq!(render_login_hint(&custom, Path::new("/custom"), None, false), custom.login_hint);
-    }
-
-    #[test]
-    fn launch_resolution_uses_the_child_path_and_absolutizes_relative_overrides() {
-        let dir = tempfile::tempdir().unwrap();
-        let mut cursor = builtin_spec("cursor").unwrap();
-        let command = if cfg!(windows) { "cursor-agent.cmd" } else { "cursor-agent" };
-        let program = dir.path().join(command);
-        std::fs::write(&program, "").unwrap();
-        cursor.env.push(("PATH".into(), dir.path().to_string_lossy().into_owned()));
-        let resolved = cursor.clone().resolve_for_launch(dir.path());
-        assert_eq!(Path::new(&resolved.command), program);
-        assert!(resolved.sign_in_message().contains(&*program.to_string_lossy()));
-        cursor.command = format!("tools/{command}");
-        let resolved = cursor.resolve_for_launch(dir.path());
-        assert_eq!(Path::new(&resolved.command), dir.path().join("tools").join(command));
-    }
-
-    #[cfg(unix)]
-    #[test]
-    fn registry_login_hint_names_the_installed_executable() {
-        let mut spec = builtin_spec("cursor").unwrap();
-        spec.command = "/registry path/dist-package/cursor-agent".into();
-        assert_eq!(
-            describe(&spec).login_hint.as_deref(),
-            Some("Run `'/registry path/dist-package/cursor-agent' login` in a terminal.")
-        );
-    }
-
    #[test]
    fn launch_metadata_distinguishes_defaults_overrides_and_read_only_agents() {
        let dir = tempfile::tempdir().unwrap();
@@ -513,23 +368,6 @@ 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();
@@ -76,8 +76,6 @@ pub struct RegistryAgent {
    pub installed: Option<String>,
    /// Whether [`Self::version`] is newer than the installed one.
    pub update: bool,
-    /// An install of it is running (it goes on after the Settings page that started it closes).
-    pub installing: bool,
 }

 #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Type)]
@@ -334,7 +332,6 @@ fn visible(
                distribution,
                no_checksum,
                installed,
-                installing: false,
            })
        })
        .collect();
@@ -3,55 +3,17 @@
 use super::*;
 use tokio::io::duplex;

-#[test]
-fn permission_uses_its_own_command_payload() {
-    let command = "python3 -c 'import pathlib\npathlib.Path(\"a.txt\").touch()'";
-    let mut request = json!({"toolCall": {"toolCallId": "write", "kind": "execute",
-        "title": "Run List .", "rawInput": {"command": command}}});
-    assert_eq!(permission_title(&request), format!("Run {command}"));
-    request["toolCall"]["title"] = json!("Allow network access to example.com");
-    assert_eq!(permission_title(&request), "Allow network access to example.com");
-    request["toolCall"].as_object_mut().unwrap().remove("title");
-    request["toolCall"].as_object_mut().unwrap().remove("rawInput");
-    request["toolCall"]["content"] = json!([{ "type": "content", "content": {"type": "text", "text": command}}]);
-    assert_eq!(permission_title(&request), format!("Run {command}"));
-}
-
-#[test]
-fn permission_shows_the_script_inside_a_shell_wrapper() {
-    let wrapped = r#"/bin/zsh -lc "python3 -c 'import pathlib\np = pathlib.Path(\"a.txt\")'""#;
-    let request = json!({"toolCall": {"toolCallId": "write", "kind": "execute",
-        "title": "Run python3", "rawInput": {"command": wrapped}}});
-    assert_eq!(permission_title(&request), "Run python3 -c 'import pathlib\\np = pathlib.Path(\"a.txt\")'");
-}
-
 /// Says "Hi", edits a file, asks to run a command and reports what it was allowed.
 #[derive(Default)]
 struct FakeAgent {
    /// Every connection's agent side, kept open.
    servers: Mutex<Vec<Peer>>,
    calls: Mutex<Vec<String>>,
-    permission_replies: Mutex<Vec<Value>>,
    /// Without `loadSession` (a session lives only as long as its process).
    no_load: bool,
-    auth_on_new: bool,
-    empty_config: AtomicBool,
-    /// Config options `session/new` reports after the model one (per-model efforts, say).
-    extra_options: Mutex<Vec<Value>>,
-    model_options: Mutex<HashMap<String, Vec<Value>>>,
 }

 impl FakeAgent {
-    fn options_for(&self, model: &str) -> Vec<Value> {
-        let mut options = vec![json!({"id": "model", "category": "model", "type": "select",
-            "currentValue": model,
-            "options": [{"value": "big", "name": "Big"}, {"value": "small", "name": "Small"},
-                {"value": "plain", "name": "Plain"}, {"value": "unknown", "name": "Unknown"}]})];
-        options
-            .extend(self.model_options.lock().get(model).cloned().unwrap_or_else(|| self.extra_options.lock().clone()));
-        options
-    }
-
    /// The connection opened last: the agent restarted, or a fork's.
    fn latest(&self) -> Peer {
        self.servers.lock().last().cloned().expect("a connection")
@@ -123,11 +85,6 @@ impl Handler for FakeAgent {

    fn on_request(&self, method: &str, params: Value) -> Result<Value, (i64, String)> {
        self.calls.lock().push(method.to_owned());
-        if (method == "session/new" && self.auth_on_new)
-            || (method == "session/prompt" && params.pointer("/prompt/0/text") == Some(&json!("auth")))
-        {
-            return Err((codes::INTERNAL_ERROR, "Authentication required".into()));
-        }
        let session = params.get("sessionId").and_then(Value::as_str).unwrap_or("s1").to_owned();
        match method {
            "initialize" => {
@@ -135,22 +92,13 @@ impl Handler for FakeAgent {
                    self.calls.lock().push("subagents".into());
                }
                Ok(json!({"protocolVersion": 1, "agentCapabilities": {"loadSession": !self.no_load,
-                    "sessionCapabilities": {"fork": {}}, "_meta": {"openidea": {"rollback": true, "steer": true, "backgroundTasks": true}}}}))
+                    "sessionCapabilities": {"fork": {}}, "_meta": {"openidea": {"rollback": true, "steer": true}}}}))
            }
-            "session/new" => {
-                if self.empty_config.load(Ordering::Acquire) {
-                    return Ok(json!({"sessionId": "s1"}));
-                }
-                let options = self.options_for("big");
-                Ok(json!({"sessionId": "s1",
+            "session/new" => Ok(json!({"sessionId": "s1",
                "modes": {"currentModeId": "ask", "availableModes": [{"id": "ask", "name": "Ask"}, {"id": "code", "name": "Code"}]},
-                "configOptions": options}))
-            }
+                "configOptions": [{"id": "model", "category": "model", "type": "select", "currentValue": "big",
+                    "options": [{"value": "big", "name": "Big"}, {"value": "small", "name": "Small"}]}]})),
            "session/fork" => Ok(json!({"sessionId": "s2"})),
-            "_openidea/stop_task" => {
-                self.calls.lock().push(format!("{method} {}", params["taskId"]));
-                Ok(json!({}))
-            }
            "_openidea/rollback" | "_openidea/steer" => {
                let detail = params.get("turns").cloned().unwrap_or_else(|| params["prompt"][0]["text"].clone());
                self.calls.lock().push(format!("{method} {detail}"));
@@ -162,9 +110,6 @@ impl Handler for FakeAgent {
            }
            "session/set_config_option" | "session/set_mode" => {
                self.calls.lock().push(format!("{method} {}", params.get("value").or(params.get("modeId")).unwrap()));
-                if params["configId"] == "model" && !self.model_options.lock().is_empty() {
-                    return Ok(json!({"configOptions": self.options_for(params["value"].as_str().unwrap())}));
-                }
                Ok(json!({}))
            }
            "session/prompt" => {
@@ -173,16 +118,6 @@ impl Handler for FakeAgent {
                    self.say(&session, "second turn");
                    return Ok(json!({"stopReason": "end_turn"}));
                }
-                if text == "background" {
-                    // A command that outlives the turn, as the agent reports it.
-                    self.update(
-                        &session,
-                        json!({"sessionUpdate": BACKGROUND_TASKS_UPDATE,
-                        "tasks": [{"task_id": "bsh1", "task_type": "local_bash", "description": "sleep 900"}]}),
-                    );
-                    self.say(&session, "running it in the background");
-                    return Ok(json!({"stopReason": "end_turn"}));
-                }
                if text == "delegate" {
                    self.delegate(&session);
                    return Ok(json!({"stopReason": "end_turn"}));
@@ -200,52 +135,6 @@ impl Handler for FakeAgent {
                    self.say(&session, "ok");
                    return Ok(json!({"stopReason": "end_turn"}));
                }
-                if text == "ask" {
-                    let peer = self.latest();
-                    let answer: Value = tokio::runtime::Handle::current()
-                        .block_on(peer.request(
-                            "session/request_permission",
-                            json!({"sessionId": session,
-                                "toolCall": {"toolCallId": "q1", "title": "AskUserQuestion", "_meta": {"questions": [
-                                    {"question": "Which layout?", "options": [{"label": "List"}, {"label": "Grid"}]},
-                                    {"question": "Which checks?", "multiSelect": true,
-                                     "options": [{"label": "Disk"}, {"label": "GPU temps"}]}]}},
-                                "options": [{"optionId": "yes", "name": "Allow", "kind": "allow_once"}]}),
-                            None,
-                        ))
-                        .unwrap();
-                    self.permission_replies.lock().push(answer.clone());
-                    let chosen = answer.pointer("/outcome/optionId").and_then(Value::as_str).unwrap_or("none");
-                    self.say(&session, &format!("answered {chosen}"));
-                    return Ok(json!({ "stopReason": "end_turn" }));
-                }
-                if text == "qwen ask" {
-                    // Qwen Code's ACP dialect: the questions as `qwenQuestions`, Submit and
-                    // Cancel as the options, the answers keyed by question index.
-                    let peer = self.latest();
-                    let answer: Value = tokio::runtime::Handle::current()
-                        .block_on(peer.request(
-                            "session/request_permission",
-                            json!({"sessionId": session,
-                                "toolCall": {"toolCallId": "q2", "title": "Ask user 2 questions", "kind": "think",
-                                    "_meta": {"toolName": "ask_user_question", "qwenInteractionKind": "user_question",
-                                        "qwenQuestions": [
-                                            {"question": "Which database?", "header": "Database", "options": [
-                                                {"label": "Postgres", "description": "Relational"},
-                                                {"label": "Redis", "description": "Key-value"}]},
-                                            {"question": "Which caches?", "header": "Caches", "multiSelect": true,
-                                             "options": [{"label": "Disk"}, {"label": "Memory"}]}]}},
-                                "options": [{"optionId": "proceed_once", "name": "Submit", "kind": "allow_once"},
-                                            {"optionId": "cancel", "name": "Cancel", "kind": "reject_once"}]}),
-                            None,
-                        ))
-                        .unwrap();
-                    let outcome = answer.pointer("/outcome/outcome").and_then(Value::as_str).unwrap_or("none");
-                    let option = answer.pointer("/outcome/optionId").and_then(Value::as_str).unwrap_or("none");
-                    let answers = answer.get("answers").cloned().unwrap_or(Value::Null);
-                    self.say(&session, &format!("answered {outcome} {option} {answers}"));
-                    return Ok(json!({ "stopReason": "end_turn" }));
-                }
                if text == "wait" {
                    // Works until cancelled.
                    while !self.calls.lock().iter().any(|c| c == "session/cancel") {
@@ -322,49 +211,6 @@ fn manager_at(dir: &Path, models_file: &Path, agent: Arc<FakeAgent>) -> AgentMan
    )
 }

-#[tokio::test(flavor = "multi_thread")]
-async fn authentication_failures_name_the_session_executable_at_start_and_during_prompts() {
-    for auth_on_new in [true, false] {
-        let tmp = tempfile::tempdir().unwrap();
-        let agent = Arc::new(FakeAgent { auth_on_new, ..Default::default() });
-        let mgr = manager(tmp.path(), agent);
-        let program = tmp.path().join("Agent Tools").join("renamed-cursor.cmd");
-        mgr.shared.providers.write().iter_mut().find(|s| s.id == "cursor").unwrap().command =
-            program.to_string_lossy().into_owned();
-        let task = mgr
-            .create(NewAgentTask {
-                project_root: None,
-                prompt: text("again"),
-                provider: "cursor".into(),
-                config: vec![],
-                isolation: Isolation::Local,
-                base: None,
-            })
-            .await
-            .unwrap();
-        if !auth_on_new {
-            wait_for(&mgr, &task.id, AgentStatus::Ready).await;
-            // A settings change must not redirect guidance for the already running process.
-            mgr.shared.providers.write().iter_mut().find(|s| s.id == "cursor").unwrap().command =
-                "different-cursor".into();
-            mgr.prompt(&task.id, text("auth"), false).await.unwrap();
-        }
-        wait_for(&mgr, &task.id, AgentStatus::Failed).await;
-        let entries = mgr.entries(&task.id, None).unwrap();
-        let error = entries
-            .iter()
-            .find_map(|e| match e {
-                AgentEntry::Error { message, .. } => Some(message),
-                _ => None,
-            })
-            .expect("authentication error");
-        assert!(error.starts_with("Cursor needs you to sign in. Run `"), "{error}");
-        assert!(error.contains(&*program.to_string_lossy()), "{error}");
-        assert!(error.ends_with(" login` in a terminal."), "{error}");
-        mgr.shutdown();
-    }
-}
-
 #[tokio::test(flavor = "multi_thread")]
 async fn commands_are_remembered_per_project_and_merged_with_skills_on_disk() {
    let tmp = tempfile::tempdir().unwrap();
@@ -742,163 +588,6 @@ fn prompts_become_acp_content_blocks() {
    assert!(clean(text(" ")).is_none());
 }

-#[tokio::test(flavor = "multi_thread")]
-async fn claude_questions_keep_the_answer_object_as_the_option_id() {
-    let tmp = tempfile::tempdir().unwrap();
-    let agent = Arc::new(FakeAgent::default());
-    let mgr = manager(tmp.path(), agent.clone());
-    let task = mgr
-        .create(NewAgentTask {
-            project_root: None,
-            prompt: text("ask"),
-            provider: "codex".into(),
-            config: vec![],
-            isolation: Isolation::Local,
-            base: None,
-        })
-        .await
-        .unwrap();
-    wait_for(&mgr, &task.id, AgentStatus::NeedsInput).await;
-    let question = mgr
-        .entries(&task.id, None)
-        .unwrap()
-        .iter()
-        .find_map(|e| match e {
-            AgentEntry::Permission { id, title, questions, .. } => {
-                assert_eq!(title, "AskUserQuestion");
-                assert_eq!(questions.len(), 2);
-                assert_eq!(questions[0].question, "Which layout?");
-                assert!(!questions[0].multi_select);
-                assert_eq!(questions[1].question, "Which checks?");
-                assert!(questions[1].multi_select);
-                Some(*id)
-            }
-            _ => None,
-        })
-        .unwrap();
-    let reply = json!({"Which layout?": ["List"], "Which checks?": ["Disk", "GPU temps"]}).to_string();
-    mgr.respond(&task.id, question, Some(reply.clone())).unwrap();
-    wait_for(&mgr, &task.id, AgentStatus::Ready).await;
-    assert_eq!(*agent.permission_replies.lock(), [json!({"outcome": {"outcome": "selected", "optionId": reply}})]);
-
-    let entries = mgr.entries(&task.id, None).unwrap();
-    assert!(
-        entries
-            .iter()
-            .any(|e| matches!(e, AgentEntry::Permission { chosen: Some(c), .. } if c == "List; Disk, GPU temps")),
-        "{entries:?}"
-    );
-}
-
-/// Qwen Code asks its questions as `_meta.qwenQuestions` with Submit/Cancel options; the
-/// card answers with `answers` keyed by question index beside the Submit option's id.
-#[tokio::test(flavor = "multi_thread")]
-async fn qwen_questions_answer_by_index_beside_the_submit_option() {
-    let tmp = tempfile::tempdir().unwrap();
-    let mgr = manager(tmp.path(), Arc::new(FakeAgent::default()));
-    let task = mgr
-        .create(NewAgentTask {
-            project_root: None,
-            prompt: text("qwen ask"),
-            provider: "codex".into(),
-            config: vec![],
-            isolation: Isolation::Local,
-            base: None,
-        })
-        .await
-        .unwrap();
-    wait_for(&mgr, &task.id, AgentStatus::NeedsInput).await;
-    let (id, title, questions) = mgr
-        .entries(&task.id, None)
-        .unwrap()
-        .iter()
-        .find_map(|e| match e {
-            AgentEntry::Permission { id, title, questions, .. } => Some((*id, title.clone(), questions.clone())),
-            _ => None,
-        })
-        .unwrap();
-    assert_eq!(title, "Which database?", "the first question, not the request's own title");
-    assert_eq!(
-        questions,
-        vec![
-            AgentQuestion {
-                answer_key: None,
-                header: "Database".into(),
-                question: "Which database?".into(),
-                multi_select: false,
-                options: vec![
-                    AgentQuestionOption { label: "Postgres".into(), description: "Relational".into(), preview: None },
-                    AgentQuestionOption { label: "Redis".into(), description: "Key-value".into(), preview: None },
-                ],
-            },
-            AgentQuestion {
-                answer_key: None,
-                header: "Caches".into(),
-                question: "Which caches?".into(),
-                multi_select: true,
-                options: vec![
-                    AgentQuestionOption { label: "Disk".into(), description: String::new(), preview: None },
-                    AgentQuestionOption { label: "Memory".into(), description: String::new(), preview: None },
-                ],
-            },
-        ]
-    );
-    let reply = json!({"Which database?": ["Postgres"], "Which caches?": ["Disk", "Memory"]}).to_string();
-    mgr.respond(&task.id, id, Some(reply)).unwrap();
-    wait_for(&mgr, &task.id, AgentStatus::Ready).await;
-
-    let entries = mgr.entries(&task.id, None).unwrap();
-    let expected = format!("answered selected proceed_once {}", json!({"0": "Postgres", "1": "Disk, Memory"}));
-    assert!(entries.iter().any(|e| matches!(e, AgentEntry::Agent { text } if text == &expected)), "{entries:?}");
-    assert!(
-        entries
-            .iter()
-            .any(|e| matches!(e, AgentEntry::Permission { chosen: Some(c), .. } if c == "Postgres; Disk, Memory")),
-        "{entries:?}"
-    );
-}
-
-/// A skipped Qwen question cancels the request: qwen-code reads the answers it expects
-/// only beside a chosen option, and `reject` is none of the options it offered.
-#[tokio::test(flavor = "multi_thread")]
-async fn skipped_qwen_questions_cancel_the_request() {
-    let tmp = tempfile::tempdir().unwrap();
-    let mgr = manager(tmp.path(), Arc::new(FakeAgent::default()));
-    let task = mgr
-        .create(NewAgentTask {
-            project_root: None,
-            prompt: text("qwen ask"),
-            provider: "codex".into(),
-            config: vec![],
-            isolation: Isolation::Local,
-            base: None,
-        })
-        .await
-        .unwrap();
-    wait_for(&mgr, &task.id, AgentStatus::NeedsInput).await;
-    let id = mgr
-        .entries(&task.id, None)
-        .unwrap()
-        .iter()
-        .find_map(|e| match e {
-            AgentEntry::Permission { id, questions, .. } if !questions.is_empty() => Some(*id),
-            _ => None,
-        })
-        .unwrap();
-    mgr.respond(&task.id, id, Some("reject".into())).unwrap();
-    wait_for(&mgr, &task.id, AgentStatus::Ready).await;
-
-    let entries = mgr.entries(&task.id, None).unwrap();
-    assert!(
-        entries.iter().any(|e| matches!(e, AgentEntry::Agent { text } if text == "answered cancelled none null")),
-        "{entries:?}"
-    );
-    assert!(
-        entries.iter().any(|e| matches!(e, AgentEntry::Permission { chosen: Some(c), .. } if c == "Cancelled")),
-        "{entries:?}"
-    );
-}
-
 #[tokio::test(flavor = "multi_thread")]
 async fn cancelling_resolves_the_open_permission_and_delete_forgets_the_task() {
    let tmp = tempfile::tempdir().unwrap();
@@ -1016,44 +705,6 @@ async fn real_claude_task_in_a_worktree() {
    mgr.shutdown();
 }

-#[tokio::test(flavor = "multi_thread")]
-async fn renamed_titles_survive_updates_forks_and_restart() {
-    let tmp = tempfile::tempdir().unwrap();
-    let agent = Arc::new(FakeAgent::default());
-    let mgr = manager(tmp.path(), agent.clone());
-    let task = mgr
-        .create(NewAgentTask {
-            project_root: None,
-            prompt: text("again"),
-            provider: "claude".into(),
-            config: Vec::new(),
-            isolation: Isolation::Local,
-            base: None,
-        })
-        .await
-        .unwrap();
-    wait_for(&mgr, &task.id, AgentStatus::Ready).await;
-    let handle = mgr.task(&task.id).unwrap();
-    assert!(mgr.rename(&task.id, "  ").is_err());
-    let initial = handle.state.lock().task.title.clone();
-    for title in [initial, "My task".to_owned(), "名".repeat(205)] {
-        mgr.rename(&task.id, &title).unwrap();
-        handle.on_update(None, &json!({"sessionUpdate": "session_info_update", "title": "Agent title"}));
-        assert_eq!(handle.state.lock().task.title, title.chars().take(200).collect::<String>());
-    }
-    mgr.rename(&task.id, "  My task  ").unwrap();
-    let copy = mgr.fork(&task.id, None).await.unwrap();
-    let copied = mgr.task(&copy.id).unwrap();
-    copied.on_update(None, &json!({"sessionUpdate": "session_info_update", "title": "Copied agent title"}));
-    assert_eq!(copied.state.lock().task.title, "My task");
-    mgr.shutdown();
-    let restored = manager(tmp.path(), agent);
-    let handle = restored.task(&task.id).unwrap();
-    handle.on_update(None, &json!({"sessionUpdate": "session_info_update", "title": "Resumed title"}));
-    assert_eq!(handle.state.lock().task.title, "My task");
-    restored.shutdown();
-}
-
 #[tokio::test(flavor = "multi_thread")]
 async fn forks_rollbacks_and_steering() {
    let tmp = tempfile::tempdir().unwrap();
@@ -1102,33 +753,6 @@ async fn forks_rollbacks_and_steering() {
    assert!(mgr.task(&task.id).unwrap().state.lock().task.queue.is_empty());
    mgr.cancel(&task.id, None).unwrap();
    wait_for(&mgr, &task.id, AgentStatus::Ready).await;
-
-    // Dropping every turn starts a fresh session instead of rewinding the agent's history.
-    let handle = mgr.task(&task.id).unwrap();
-    for (parent, child) in [(None, "child"), (Some("child"), "grandchild")] {
-        handle.on_update(
-            parent,
-            &json!({"sessionUpdate": "subagent_update", "sessionId": child,
-            "state": {"state": "idle", "stopReason": "end_turn"}}),
-        );
-    }
-    handle.state.lock().conversation.main.entries.insert(0, AgentEntry::Agent { text: "Welcome".into() });
-    let rewinds = agent.calls.lock().iter().filter(|c| c.starts_with("_openidea/rollback")).count();
-    let first = mgr.rollback(&task.id, 0).await.unwrap().unwrap();
-    assert_eq!(first.text, "again");
-    assert!(mgr.entries(&task.id, None).unwrap().is_empty());
-    assert!(mgr.task(&task.id).unwrap().state.lock().session_id.is_none());
-    assert!(handle.state.lock().conversation.saved_subagents().is_empty());
-    assert!(handle.state.lock().task.usage.is_none());
-    assert_eq!(agent.calls.lock().iter().filter(|c| c.starts_with("_openidea/rollback")).count(), rewinds);
-    mgr.shutdown();
-    let restored = manager(tmp.path(), agent.clone());
-    assert!(restored.entries(&task.id, None).unwrap().is_empty());
-    restored.prompt(&task.id, first, false).await.unwrap();
-    wait_for(&restored, &task.id, AgentStatus::Ready).await;
-    assert_eq!(turn_starts(&restored.entries(&task.id, None).unwrap()).len(), 1);
-    assert_eq!(agent.calls.lock().last().unwrap(), "session/prompt");
-    restored.shutdown();
 }

 #[tokio::test(flavor = "multi_thread")]
@@ -1162,230 +786,6 @@ async fn usage_limits_and_late_settings() {
    assert!(agent.calls.lock().iter().any(|c| c == "session/set_config_option \"high\""));
    let config = mgr.task(&task.id).unwrap().state.lock().task.config.clone();
    assert_eq!(config.iter().find(|o| o.id == "effort").unwrap().current.as_deref(), Some("high"));
-    for _ in 0..100 {
-        if mgr
-            .shared
-            .known
-            .lock()
-            .get("claude")
-            .and_then(|k| k.thought_levels.get("big"))
-            .and_then(|levels| levels.first())
-            .and_then(|o| o.current.as_deref())
-            == Some("high")
-        {
-            break;
-        }
-        tokio::time::sleep(Duration::from_millis(10)).await;
-    }
-    assert_eq!(mgr.shared.known.lock()["claude"].thought_levels["big"][0].current.as_deref(), Some("high"));
-}
-
-#[tokio::test(flavor = "multi_thread")]
-async fn remembered_settings_drop_per_model_choices_for_the_next_task() {
-    let tmp = tempfile::tempdir().unwrap();
-    let agent = Arc::new(FakeAgent::default());
-    // The effort list depends on the model: what the last session ran means nothing once
-    // the user picks another model, so provider-wide defaults never include it.
-    *agent.extra_options.lock() = vec![json!({"id": "effort", "category": "thought_level",
-        "type": "select", "currentValue": "high",
-        "options": [{"value": "low", "name": "Low"}, {"value": "high", "name": "High"}]})];
-    let mgr = manager(tmp.path(), agent.clone());
-    let task = mgr
-        .create(NewAgentTask {
-            project_root: None,
-            prompt: text("again"),
-            provider: "claude".into(),
-            config: vec![],
-            isolation: Isolation::Local,
-            base: None,
-        })
-        .await
-        .unwrap();
-    wait_for(&mgr, &task.id, AgentStatus::Ready).await;
-
-    let provider = mgr.providers().into_iter().find(|p| p.id == "claude").unwrap();
-    assert!(provider.config.iter().all(|o| o.id != "effort"), "a per-model option isn't offered stale");
-    let model = provider.config.iter().find(|o| o.id == "model").unwrap();
-    assert_eq!(model.current.as_deref(), Some("big"), "the model choice survives");
-}
-
-fn effort_options(levels: &[&str], current: &str) -> Vec<Value> {
-    vec![json!({"id": "effort", "category": "thought_level", "type": "select", "currentValue": current,
-        "options": levels.iter().map(|v| json!({"value": v, "name": v})).collect::<Vec<_>>()})]
-}
-
-#[tokio::test(flavor = "multi_thread")]
-async fn thinking_levels_are_remembered_per_provider_and_model() {
-    let tmp = tempfile::tempdir().unwrap();
-    let agent = Arc::new(FakeAgent::default());
-    *agent.model_options.lock() = HashMap::from([
-        ("big".into(), effort_options(&["low", "high"], "high")),
-        ("small".into(), effort_options(&["minimal", "medium"], "minimal")),
-        ("plain".into(), vec![]),
-    ]);
-    let mgr = manager(tmp.path(), agent.clone());
-    let task = mgr
-        .create(NewAgentTask {
-            project_root: None,
-            prompt: text("again"),
-            provider: "claude".into(),
-            config: vec![],
-            isolation: Isolation::Local,
-            base: None,
-        })
-        .await
-        .unwrap();
-    wait_for(&mgr, &task.id, AgentStatus::Ready).await;
-    mgr.set_config(&task.id, "model", "small".into()).await.unwrap();
-    mgr.set_config(&task.id, "effort", "medium".into()).await.unwrap();
-    mgr.set_config(&task.id, "model", "plain".into()).await.unwrap();
-    let p = mgr.providers().into_iter().find(|p| p.id == "claude").unwrap();
-    let big = &p.thought_levels["big"][0];
-    assert_eq!(big.current.as_deref(), Some("high"));
-    assert_eq!(big.values.iter().map(|v| v.value.as_str()).collect::<Vec<_>>(), ["low", "high"]);
-    let small = &p.thought_levels["small"][0];
-    assert_eq!(small.current.as_deref(), Some("medium"));
-    assert_eq!(small.values.iter().map(|v| v.value.as_str()).collect::<Vec<_>>(), ["minimal", "medium"]);
-    assert!(p.thought_levels["plain"].is_empty());
-    assert!(!p.thought_levels.contains_key("unknown"));
-    assert!(mgr.providers().iter().find(|p| p.id == "codex").unwrap().thought_levels.is_empty());
-    let saved: HashMap<String, Known> =
-        serde_json::from_slice(&std::fs::read(&mgr.shared.paths.models_file).unwrap()).unwrap();
-    assert_eq!(saved["claude"].thought_levels, p.thought_levels);
-    mgr.shutdown();
-    let restored = manager(tmp.path(), agent);
-    assert_eq!(restored.providers().into_iter().find(|p| p.id == "claude").unwrap().thought_levels, p.thought_levels);
-    restored.shutdown();
-}
-
-#[tokio::test(flavor = "multi_thread")]
-async fn upfront_effort_is_validated_after_changing_model_before_the_prompt() {
-    for (effort, applied) in [("medium", true), ("high", false)] {
-        let tmp = tempfile::tempdir().unwrap();
-        let agent = Arc::new(FakeAgent::default());
-        *agent.model_options.lock() = HashMap::from([
-            ("big".into(), effort_options(&["low", "high"], "low")),
-            ("small".into(), effort_options(&["minimal", "medium"], "minimal")),
-        ]);
-        let mgr = manager(tmp.path(), agent.clone());
-        let task = mgr
-            .create(NewAgentTask {
-                project_root: None,
-                prompt: text("again"),
-                provider: "claude".into(),
-                // Reversed on purpose: model must be set before validating effort.
-                config: vec![
-                    AgentConfigChoice { id: "effort".into(), value: effort.into() },
-                    AgentConfigChoice { id: "model".into(), value: "small".into() },
-                ],
-                isolation: Isolation::Local,
-                base: None,
-            })
-            .await
-            .unwrap();
-        wait_for(&mgr, &task.id, AgentStatus::Ready).await;
-        let calls = agent.calls.lock();
-        let model = calls.iter().position(|c| c == "session/set_config_option \"small\"").unwrap();
-        let effort_call = calls.iter().position(|c| c == &format!("session/set_config_option \"{effort}\""));
-        assert_eq!(effort_call.is_some(), applied);
-        if let Some(effort_call) = effort_call {
-            let prompt = calls.iter().position(|c| c == "session/prompt").unwrap();
-            assert!(model < effort_call && effort_call < prompt);
-        }
-        drop(calls);
-        mgr.shutdown();
-    }
-}
-
-#[tokio::test(flavor = "multi_thread")]
-async fn unreported_model_switch_does_not_cache_the_previous_models_levels() {
-    let tmp = tempfile::tempdir().unwrap();
-    let agent = Arc::new(FakeAgent::default());
-    *agent.extra_options.lock() = effort_options(&["low", "high"], "high");
-    let mgr = manager(tmp.path(), agent);
-    let task = mgr
-        .create(NewAgentTask {
-            project_root: None,
-            prompt: text("again"),
-            provider: "claude".into(),
-            config: vec![],
-            isolation: Isolation::Local,
-            base: None,
-        })
-        .await
-        .unwrap();
-    wait_for(&mgr, &task.id, AgentStatus::Ready).await;
-    mgr.set_config(&task.id, "model", "small".into()).await.unwrap();
-    let p = mgr.providers().into_iter().find(|p| p.id == "claude").unwrap();
-    assert!(!p.thought_levels.contains_key("small"));
-    assert_eq!(p.thought_levels["big"][0].current.as_deref(), Some("high"));
-    mgr.shutdown();
-}
-
-#[tokio::test(flavor = "multi_thread")]
-async fn cached_effort_is_not_sent_without_real_session_options() {
-    let tmp = tempfile::tempdir().unwrap();
-    let agent = Arc::new(FakeAgent::default());
-    *agent.extra_options.lock() = effort_options(&["low", "high"], "low");
-    let mgr = manager(tmp.path(), agent.clone());
-    let new = |config| NewAgentTask {
-        project_root: None,
-        prompt: text("again"),
-        provider: "claude".into(),
-        config,
-        isolation: Isolation::Local,
-        base: None,
-    };
-    let warm = mgr.create(new(vec![])).await.unwrap();
-    wait_for(&mgr, &warm.id, AgentStatus::Ready).await;
-    agent.calls.lock().clear();
-    agent.empty_config.store(true, Ordering::Release);
-    let task = mgr
-        .create(new(vec![
-            AgentConfigChoice { id: "model".into(), value: "big".into() },
-            AgentConfigChoice { id: "effort".into(), value: "high".into() },
-        ]))
-        .await
-        .unwrap();
-    wait_for(&mgr, &task.id, AgentStatus::Ready).await;
-    assert!(!agent.calls.lock().iter().any(|c| c == "session/set_config_option \"high\""));
-    assert!(
-        mgr.task(&task.id).unwrap().state.lock().task.config.iter().any(|o| o.id == "effort"),
-        "remembered session settings remain visible until the agent refreshes them"
-    );
-    mgr.shutdown();
-}
-
-#[tokio::test(flavor = "multi_thread")]
-async fn reported_levels_refresh_even_without_a_model_option() {
-    let tmp = tempfile::tempdir().unwrap();
-    let agent = Arc::new(FakeAgent::default());
-    *agent.extra_options.lock() = effort_options(&["low", "high"], "high");
-    let mgr = manager(tmp.path(), agent.clone());
-    let task = mgr
-        .create(NewAgentTask {
-            project_root: None,
-            prompt: text("again"),
-            provider: "claude".into(),
-            config: vec![],
-            isolation: Isolation::Local,
-            base: None,
-        })
-        .await
-        .unwrap();
-    wait_for(&mgr, &task.id, AgentStatus::Ready).await;
-    for levels in [effort_options(&["minimal", "medium"], "medium"), vec![]] {
-        agent.update("s1", json!({"sessionUpdate": "config_option_update", "configOptions": levels}));
-        let expected = config::parse_options(&json!(levels));
-        for _ in 0..100 {
-            if mgr.shared.known.lock()["claude"].thought_levels["big"] == expected {
-                break;
-            }
-            tokio::time::sleep(Duration::from_millis(10)).await;
-        }
-        assert_eq!(mgr.shared.known.lock()["claude"].thought_levels["big"], expected);
-    }
-    mgr.shutdown();
 }

 #[test]
@@ -1457,64 +857,6 @@ async fn cursor_approval_switch_resolves_pending_and_survives_restart() {
    mgr.shutdown();
 }

-#[tokio::test(flavor = "multi_thread")]
-async fn bypass_approvals_keeps_both_question_dialects_pending_but_allows_permissions() {
-    for prompt in ["ask", "qwen ask"] {
-        for bypass_at_start in [false, true] {
-            let tmp = tempfile::tempdir().unwrap();
-            let mgr = manager(tmp.path(), Arc::new(FakeAgent::default()));
-            // Cursor's client-side approval policy applies independently of the question dialect.
-            let task = mgr
-                .create(NewAgentTask {
-                    project_root: None,
-                    prompt: text(prompt),
-                    provider: "cursor".into(),
-                    config: if bypass_at_start {
-                        vec![AgentConfigChoice { id: config::CURSOR_APPROVAL.into(), value: "bypass".into() }]
-                    } else {
-                        vec![]
-                    },
-                    isolation: Isolation::Local,
-                    base: None,
-                })
-                .await
-                .unwrap();
-            wait_for(&mgr, &task.id, AgentStatus::NeedsInput).await;
-            let id = mgr
-                .entries(&task.id, None)
-                .unwrap()
-                .iter()
-                .find_map(|entry| match entry {
-                    AgentEntry::Permission { id, questions, chosen: None, .. } if questions.len() == 2 => Some(*id),
-                    _ => None,
-                })
-                .unwrap();
-            mgr.set_config(&task.id, config::CURSOR_APPROVAL, "bypass".into()).await.unwrap();
-            assert!(mgr.task(&task.id).unwrap().permissions.lock().contains_key(&id), "{prompt}, {bypass_at_start}");
-            assert_eq!(mgr.task(&task.id).unwrap().state.lock().task.status, AgentStatus::NeedsInput);
-            let reply = if prompt == "ask" {
-                json!({"Which layout?": ["Grid"], "Which checks?": ["Disk"]})
-            } else {
-                json!({"Which database?": ["Postgres"], "Which caches?": ["Memory"]})
-            };
-            mgr.respond(&task.id, id, Some(reply.to_string())).unwrap();
-            wait_for(&mgr, &task.id, AgentStatus::Ready).await;
-
-            mgr.prompt(&task.id, text("Fix"), false).await.unwrap();
-            wait_for(&mgr, &task.id, AgentStatus::Ready).await;
-            let entries = mgr.entries(&task.id, None).unwrap();
-            assert!(
-                entries.iter().any(|entry| matches!(entry,
-                    AgentEntry::Permission { questions, chosen: Some(name), .. }
-                    if questions.is_empty() && name == "Allow")),
-                "{entries:?}"
-            );
-            assert!(entries.iter().any(|entry| matches!(entry, AgentEntry::Agent { text } if text == "chose yes")));
-            mgr.shutdown();
-        }
-    }
-}
-
 #[tokio::test(flavor = "multi_thread")]
 async fn cursor_approval_choice_applies_before_first_prompt() {
    let tmp = tempfile::tempdir().unwrap();
@@ -1767,222 +1109,3 @@ async fn idle_agents_stop_and_resume_their_session_on_the_next_message() {
    assert!(live(&mgr, &task.id));
    mgr.shutdown();
 }
-
-/// A turn's background tasks outlive it: an idle agent stops only once its last one is
-/// done, and the usual delay runs from that report.
-#[tokio::test(flavor = "multi_thread")]
-async fn an_idle_agent_waits_for_its_background_tasks_before_it_stops() {
-    let live =
-        |mgr: &AgentManager, id: &str| mgr.task(id).unwrap().live.lock().as_ref().is_some_and(|l| !l.peer.is_closed());
-    let new = || NewAgentTask {
-        project_root: None,
-        prompt: text("background"),
-        provider: "claude".into(),
-        config: Vec::new(),
-        isolation: Isolation::Local,
-        base: None,
-    };
-
-    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;
-    // The task runs long past the idle delay: the agent stays up for it.
-    tokio::time::sleep(Duration::from_millis(600)).await;
-    assert!(live(&mgr, &task.id));
-    // It is done: the delay starts over from this report, then the agent stops.
-    agent.update("s1", json!({"sessionUpdate": BACKGROUND_TASKS_UPDATE, "tasks": []}));
-    tokio::time::sleep(Duration::from_millis(100)).await;
-    assert!(live(&mgr, &task.id), "the delay runs from when the last task is done");
-    tokio::time::sleep(Duration::from_millis(600)).await;
-    assert!(!live(&mgr, &task.id));
-    assert_eq!(mgr.task(&task.id).unwrap().state.lock().task.status, AgentStatus::Ready, "not an error");
-    mgr.shutdown();
-}
-
-#[tokio::test(flavor = "multi_thread")]
-async fn the_task_shows_what_runs_in_the_background() {
-    let tmp = tempfile::tempdir().unwrap();
-    let agent = Arc::new(FakeAgent::default());
-    let mgr = manager(tmp.path(), agent.clone());
-    let task = mgr
-        .create(NewAgentTask {
-            project_root: None,
-            prompt: text("background"),
-            provider: "claude".into(),
-            config: Vec::new(),
-            isolation: Isolation::Local,
-            base: None,
-        })
-        .await
-        .unwrap();
-    wait_for(&mgr, &task.id, AgentStatus::Ready).await;
-    let shown = || mgr.task(&task.id).unwrap().state.lock().task.background.clone();
-    let first = shown();
-    assert_eq!(first.len(), 1);
-    assert_eq!(
-        (first[0].id.as_str(), first[0].kind.as_str(), first[0].description.as_str()),
-        ("bsh1", "local_bash", "sleep 900")
-    );
-
-    agent.update(
-        "s1",
-        json!({"sessionUpdate": BACKGROUND_TASKS_UPDATE, "tasks": [
-            {"task_id": "bsh1", "task_type": "local_bash", "description": "sleep 900"},
-            {"task_id": "mon1", "task_type": "monitor", "description": "Watch the deploy"},
-        ]}),
-    );
-    tokio::time::timeout(Duration::from_secs(5), async {
-        while shown().len() < 2 {
-            tokio::time::sleep(Duration::from_millis(10)).await;
-        }
-    })
-    .await
-    .unwrap();
-    assert_eq!(shown()[0].started_ms, first[0].started_ms, "a task keeps when it was first seen");
-
-    agent.update("s1", json!({"sessionUpdate": BACKGROUND_TASKS_UPDATE, "tasks": []}));
-    tokio::time::timeout(Duration::from_secs(5), async {
-        while !shown().is_empty() {
-            tokio::time::sleep(Duration::from_millis(10)).await;
-        }
-    })
-    .await
-    .unwrap();
-    mgr.shutdown();
-}
-
-#[tokio::test(flavor = "multi_thread")]
-async fn a_background_task_is_stopped_on_its_own() {
-    let tmp = tempfile::tempdir().unwrap();
-    let agent = Arc::new(FakeAgent::default());
-    let mgr = manager(tmp.path(), agent.clone());
-    let task = mgr
-        .create(NewAgentTask {
-            project_root: None,
-            prompt: text("again"),
-            provider: "claude".into(),
-            config: Vec::new(),
-            isolation: Isolation::Local,
-            base: None,
-        })
-        .await
-        .unwrap();
-    wait_for(&mgr, &task.id, AgentStatus::Ready).await;
-    mgr.stop_background(&task.id, "b1").await.unwrap();
-    assert!(agent.calls.lock().contains(&"_openidea/stop_task \"b1\"".to_owned()));
-    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");
-}
@@ -290,8 +290,7 @@ impl Timeline {
    /// and records when the turn ended (`done`) on the message that started it.
    pub fn end_turn(&mut self, done: Option<f64>) -> Vec<usize> {
        let mut changed = Vec::new();
-        // A steered message rides along in a running turn; the one that started it owns its end.
-        let started = self.entries.iter().rposition(|e| matches!(e, AgentEntry::User { steered: false, .. }));
+        let started = self.entries.iter().rposition(|e| matches!(e, AgentEntry::User { .. }));
        for (i, e) in self.entries.iter_mut().enumerate() {
            match e {
                AgentEntry::User { done_ms, .. } if Some(i) == started && done.is_some() && done_ms.is_none() => {
@@ -435,13 +434,7 @@ mod tests {
        t.push(AgentEntry::Agent { text: "between".into() });
        assert_eq!(t.apply(&plan("completed")).changed, vec![0]);
        t.apply(&json!({"sessionUpdate": "tool_call", "toolCallId": "c", "title": "Run", "status": "in_progress"}));
-        t.push(AgentEntry::Permission {
-            id: 1,
-            title: "Run?".into(),
-            options: vec![],
-            questions: vec![],
-            chosen: None,
-        });
+        t.push(AgentEntry::Permission { id: 1, title: "Run?".into(), options: vec![], chosen: None });
        assert_eq!(t.end_turn(None), vec![2, 3]);
        let again = Timeline::from_entries(t.entries.clone());
        assert_eq!(again.plan, Some(0));
@@ -469,27 +462,6 @@ mod tests {
        assert_eq!(t.end_turn(Some(9.0)), Vec::<usize>::new());
    }

-    #[test]
-    fn end_turn_records_on_the_message_that_started_the_turn() {
-        let user = |sent: f64, steered: bool| AgentEntry::User {
-            text: "q".into(),
-            attachments: vec![],
-            images: vec![],
-            sent_ms: Some(sent),
-            done_ms: None,
-            steered,
-        };
-        let mut t = Timeline::default();
-        t.push(user(1.0, false));
-        t.push(AgentEntry::Agent { text: "a".into() });
-        t.push(user(2.0, true));
-        // The steered message rides along in the turn: the reply's time belongs to the
-        // message that started it.
-        assert_eq!(t.end_turn(Some(5.0)), vec![0]);
-        assert!(matches!(t.entries[0], AgentEntry::User { done_ms: Some(5.0), .. }));
-        assert!(matches!(t.entries[2], AgentEntry::User { done_ms: None, .. }));
-    }
-
    #[test]
    fn long_output_keeps_its_tail() {
        let s = tail("é".repeat(MAX_OUTPUT));
@@ -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::{Duration, UNIX_EPOCH};
+use std::time::UNIX_EPOCH;

 pub(crate) struct Created {
    pub path: PathBuf,
@@ -65,27 +65,7 @@ pub(crate) fn remove(project_root: &Path, worktrees_dir: &Path, path: &Path) ->
    if !path.starts_with(worktrees_dir) || path == worktrees_dir {
        return Err(err);
    }
-    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,
-    }
+    std::fs::remove_dir_all(path).map_err(|e| IdeError::internal(e.to_string()))
 }

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

 [dependencies]
-blake3.workspace = true
 dunce.workspace = true
 ide-core.workspace = true
 zip.workspace = true
@@ -40,7 +40,7 @@ pub fn plan(root: &Path, model: &BuildModel, module: &Path, cache: &Path) -> Ide
            kind: "maven",
        });
    }
-    if let Some(g) = model.gradle_for_module(root, &module)
+    if let Some(g) = &model.gradle
        && let Some(p) = g.projects.iter().find(|p| root.join(&p.dir) == module)
    {
        let script = cache.join("resources.init.gradle");
@@ -163,11 +163,11 @@ mod tests {
        assert!(maven.args.contains(&"-Dexpression=project.build.outputDirectory".into()));
        assert_eq!(maven.env["JAVA_HOME"], "/jdk");
        model.maven = None;
-        model.gradle = vec![crate::GradleModel {
+        model.gradle = Some(crate::GradleModel {
            command: "/tools/gradlew".into(),
            projects: vec![crate::GradleProject { path: ":app".into(), dir: "app".into(), ..Default::default() }],
            ..Default::default()
-        }];
+        });
        let gradle = plan(&root, &model, Path::new("app"), &cache).unwrap();
        assert_eq!(gradle.command, "/tools/gradlew");
        assert_eq!(gradle.args.last().unwrap(), ":app:openideaUpdateResources");
@@ -2,49 +2,18 @@
 use super::*;
 use std::fs;
 use std::hash::{Hash, Hasher};
-use std::io::Read;
 use std::time::SystemTime;

-/// `(byte length, mtime, blake3 hex)`; the hash is recorded for files inside the project only.
-type Stamp = (u64, SystemTime, Option<String>);
-
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct LaunchFingerprint {
    version: u32,
    parameters: String,
-    /// Per input: a [`Stamp`] for regular files, `None` for
-    /// directories and inputs that cannot be resolved. The content hash catches external
-    /// edits that preserve both length and mtime (timestamp-preserving tools, coarse
-    /// timestamp granularity), which `(length, mtime)` alone would miss. Only files inside
-    /// the project are hashed; toolchain inputs such as the JDK's `lib/modules` keep the stamp.
-    files: BTreeMap<PathBuf, Option<Stamp>>,
-}
-
-/// `blake3` hex of a file's bytes, streamed in chunks so memory stays bounded. An
-/// unreadable file records a sentinel so one permission problem does not drop the whole
-/// fingerprint (that would just force a normal rebuild).
-fn content_hash(path: &Path) -> IdeResult<String> {
-    let mut file = match fs::File::open(path) {
-        Ok(file) => file,
-        Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok("missing".into()),
-        Err(e) => return Err(e.into()),
-    };
-    let mut hasher = blake3::Hasher::new();
-    let mut buffer = [0; 64 * 1024];
-    loop {
-        let count = file.read(&mut buffer)?;
-        if count == 0 {
-            break;
-        }
-        hasher.update(&buffer[..count]);
-    }
-    Ok(hasher.finalize().to_hex().to_string())
+    files: BTreeMap<PathBuf, Option<(u64, SystemTime)>>,
 }

 fn scan(
-    root: &Path,
    path: &Path,
-    files: &mut BTreeMap<PathBuf, Option<Stamp>>,
+    files: &mut BTreeMap<PathBuf, Option<(u64, SystemTime)>>,
    ancestors: &mut HashSet<PathBuf>,
    cancel: &CancellationToken,
 ) -> IdeResult<()> {
@@ -67,12 +36,11 @@ fn scan(
        // Directory mtimes change on irrelevant JDT writes. File paths detect additions/deletions.
        files.insert(path.to_path_buf(), None);
        for entry in fs::read_dir(path)? {
-            scan(root, &entry?.path(), files, ancestors, cancel)?;
+            scan(&entry?.path(), files, ancestors, cancel)?;
        }
        ancestors.remove(&canonical);
    } else if meta.is_file() {
-        let hash = if path.starts_with(root) { Some(content_hash(path)?) } else { None };
-        files.insert(path.to_path_buf(), Some((meta.len(), meta.modified()?, hash)));
+        files.insert(path.to_path_buf(), Some((meta.len(), meta.modified()?)));
    } else {
        return Err(IdeError::internal("unsupported launch input file"));
    }
@@ -177,11 +145,11 @@ pub fn launch_fingerprint(
            .map_err(|e| IdeError::internal(e.to_string()))?;
    let mut files = BTreeMap::new();
    for path in inputs {
-        scan(root, &path, &mut files, &mut HashSet::new(), cancel)?;
+        scan(&path, &mut files, &mut HashSet::new(), cancel)?;
    }
    // Store project inputs relative to the project, including each file's relative path.
    let files = files.into_iter().map(|(p, stamp)| (p.strip_prefix(root).unwrap_or(&p).to_path_buf(), stamp)).collect();
-    Ok(Some(LaunchFingerprint { version: 2, parameters, files }))
+    Ok(Some(LaunchFingerprint { version: 1, parameters, files }))
 }

 #[cfg(test)]
@@ -263,25 +231,6 @@ mod tests {
        }
    }

-    /// An external tool that keeps the byte length and the mtime (timestamp-preserving
-    /// writes, coarse-granularity filesystems) still changes the content: the fingerprint
-    /// must differ via the content hash, not via `(length, mtime)`.
-    #[test]
-    fn external_edit_preserving_length_and_mtime_still_invalidates() {
-        let dir = tempfile::tempdir().unwrap();
-        let root = dir.path();
-        let model = fixture(root);
-        let source = root.join("lib/src/main/kotlin/Channel.kt");
-        let before = fingerprint(root, &model);
-        assert!(before.is_some());
-        let mtime = fs::metadata(&source).unwrap().modified().unwrap();
-        // Same 5-byte length, different content.
-        write(root, "lib/src/main/kotlin/Channel.kt", "valve");
-        fs::File::options().write(true).open(&source).unwrap().set_modified(mtime).unwrap();
-        let after = fingerprint(root, &model);
-        assert_ne!(before, after, "a same-length, same-mtime content change must invalidate the fingerprint");
-    }
-
    #[test]
    fn profile_options_jdk_goal_and_wrapper_invalidate_without_using_class_outputs() {
        let dir = tempfile::tempdir().unwrap();
@@ -10,7 +10,6 @@ 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};
@@ -42,8 +41,6 @@ pub enum BuildSystem {
    Go,
    #[serde(rename = "typescript")]
    TypeScript,
-    #[serde(rename = "cmake")]
-    CMake,
 }

 /// One command of a build.
@@ -67,11 +64,6 @@ impl BuildStep {
        }
    }

-    /// A CMake configure/build invocation, parsed as compiler output in the Build view.
-    pub fn cmake(program: &str, args: Vec<String>, cwd: PathBuf, env: BTreeMap<String, String>) -> Self {
-        Self { program: program.into(), args, cwd, env, format: Format::Gcc }
-    }
-
    /// The command line as echoed in the console.
    pub fn display(&self) -> String {
        let program = Path::new(&self.program).file_name().map_or(self.program.clone(), |n| n.to_string_lossy().into());
@@ -152,30 +144,29 @@ fn detect_dir(dir: &Path, model: &BuildModel, root: &Path) -> Option<BuildSystem
    let rel = rel_str(root, dir);
    if model.maven.as_ref().is_some_and(|m| m.projects.iter().any(|p| p.dir == rel)) || has(dir, &["pom.xml"]) {
        Some(BuildSystem::Maven)
-    } else if model.gradle_for_module(root, dir).is_some()
-        || has(dir, &["build.gradle", "build.gradle.kts", "settings.gradle", "settings.gradle.kts"])
-    {
+    } else if has(dir, &["build.gradle", "build.gradle.kts", "settings.gradle", "settings.gradle.kts"]) {
        Some(BuildSystem::Gradle)
    } else if has(dir, &["Cargo.toml"]) {
        Some(BuildSystem::Cargo)
-    } else if has(dir, &["go.mod", "go.work"]) {
+    } else if has(dir, &["go.mod"]) {
        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
    }
 }

-/// Resolves a workspace-relative or absolute directory with native path separators.
+/// `root/rel`, without a trailing separator for the root itself.
+/// `root` / `rel`, joined per `/`-separated component: on Windows a single join of
+/// `a/b` keeps the `/`, and such a path does not compare equal to the same directory
+/// as other tools (JDT LS) spell it.
 fn subdir(root: &Path, rel: &str) -> PathBuf {
-    root.join(rel).components().collect()
+    rel.split('/').filter(|part| !part.is_empty()).fold(root.to_path_buf(), |path, part| path.join(part))
 }

 fn rel_str(root: &Path, dir: &Path) -> String {
-    dir.strip_prefix(root).unwrap_or(dir).to_string_lossy().replace('\\', "/")
+    dir.strip_prefix(root).map(|r| r.to_string_lossy().replace('\\', "/")).unwrap_or_default()
 }

 /// Directories from `file`'s folder up to `root` (inclusive).
@@ -185,25 +176,11 @@ 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).
-/// `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> {
+pub fn plan(root: &Path, model: &BuildModel, kind: BuildKind, file: Option<&Path>) -> 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) => {
-            let scope = model
-                .gradle
-                .iter()
-                .flat_map(|g| std::iter::once(root.join(&g.dir)).chain(g.projects.iter().map(|p| root.join(&p.dir))))
-                .filter(|dir| f.starts_with(dir))
-                .max_by_key(|dir| dir.components().count())
-                .unwrap_or_else(|| root.to_path_buf());
-            let dir = ancestors_within(&scope, f)
+            let dir = ancestors_within(root, f)
                .find(|d| detect_dir(d, model, root).is_some())
                .ok_or_else(|| IdeError::not_found(format!("{} is not in a module", f.display())))?;
            Some(dir.to_path_buf())
@@ -213,11 +190,9 @@ pub fn plan(
    let dir = module_dir.clone().unwrap_or_else(|| root.to_path_buf());
    // A folder of sibling projects has no build file itself; its Maven projects are built one by one.
    let system = detect_dir(&dir, model, root)
-        .or((!model.gradle.is_empty()).then_some(BuildSystem::Gradle))
+        .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, CMake) found")
-        })?;
+        .ok_or_else(|| IdeError::not_found("no supported build system (Maven, Gradle, Cargo, Go, TypeScript) found"))?;
    let module = module_dir.as_deref().filter(|d| *d != root);
    let title = match module {
        Some(d) => format!(
@@ -232,19 +207,13 @@ pub fn plan(
        BuildSystem::Gradle => gradle_steps(root, model, kind, module_dir.as_deref())?,
        BuildSystem::Cargo => cargo_steps(&dir, kind),
        // Go builds the file's package (a module holds many).
-        BuildSystem::Go => go_steps(file.and_then(Path::parent).unwrap_or(&dir), kind)?,
+        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 })
 }

-pub(super) fn maven_steps(
-    root: &Path,
-    model: &BuildModel,
-    kind: BuildKind,
-    module: Option<&Path>,
-) -> IdeResult<Vec<BuildStep>> {
+fn maven_steps(root: &Path, model: &BuildModel, kind: BuildKind, module: Option<&Path>) -> IdeResult<Vec<BuildStep>> {
    let fallback;
    let m = match &model.maven {
        Some(m) => m,
@@ -286,16 +255,14 @@ pub(super) fn maven_steps(
 }

 fn gradle_steps(root: &Path, model: &BuildModel, kind: BuildKind, module: Option<&Path>) -> IdeResult<Vec<BuildStep>> {
-    if module.is_none() && !model.gradle.is_empty() {
-        return Ok(model.gradle.iter().flat_map(|g| gradle_step(root, g, kind, None)).collect());
-    }
-    let g = module
-        .and_then(|m| model.gradle_for_module(root, m))
-        .ok_or_else(|| IdeError::not_found("module does not belong to a linked Gradle build"))?;
-    Ok(gradle_step(root, g, kind, module))
-}
-
-fn gradle_step(root: &Path, g: &crate::GradleModel, kind: BuildKind, module: Option<&Path>) -> Vec<BuildStep> {
+    let fallback;
+    let g = match &model.gradle {
+        Some(g) => g,
+        None => {
+            fallback = crate::gradle::load(root).ok_or_else(|| IdeError::not_found("no Gradle build found"))?;
+            &fallback
+        }
+    };
    let prefix = module
        .and_then(|m| {
            let rel = rel_str(root, m);
@@ -314,7 +281,7 @@ fn gradle_step(root: &Path, g: &crate::GradleModel, kind: BuildKind, module: Opt
    let mut s = BuildStep::new(&g.command, &["--console=plain"], &subdir(root, &g.dir), Format::Gradle);
    s.args.extend(tasks);
    s.env = g.env.clone();
-    vec![s]
+    Ok(vec![s])
 }

 fn cargo_steps(dir: &Path, kind: BuildKind) -> Vec<BuildStep> {
@@ -335,77 +302,7 @@ 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) -> IdeResult<Vec<BuildStep>> {
-    if dir.join("go.work").is_file() {
-        let work_file = dunce::canonicalize(dir.join("go.work"))?;
-        let modules = ide_core::go::work_modules(&std::fs::read_to_string(dir.join("go.work"))?);
-        if modules.is_empty() {
-            return Err(IdeError::invalid("The Go workspace contains no modules"));
-        }
-        let mut steps = Vec::new();
-        for module in modules {
-            let module = dir.join(module);
-            if !module.join("go.mod").is_file() {
-                return Err(IdeError::not_found(format!("Go workspace module has no go.mod: {}", module.display())));
-            }
-            // Go compares workspace membership against cwd paths lexically.
-            let module = dunce::canonicalize(module)?;
-            let mut module_steps = go_module_steps(&module, kind);
-            for step in &mut module_steps {
-                step.env.insert("GOWORK".into(), work_file.to_string_lossy().into_owned());
-            }
-            steps.extend(module_steps);
-        }
-        return Ok(steps);
-    }
-    Ok(go_module_steps(dir, kind))
-}
-
-fn go_module_steps(dir: &Path, kind: BuildKind) -> Vec<BuildStep> {
+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)) };
    let mut args = vec!["build"];
@@ -419,7 +316,18 @@ fn go_module_steps(dir: &Path, kind: BuildKind) -> Vec<BuildStep> {

 /// `pnpm` / `yarn` / `bun` / `npm`, from the lock file next to `package.json` or above it.
 fn package_manager(dir: &Path) -> &'static str {
-    ide_core::project_roots::package_manager(dir)
+    for d in dir.ancestors() {
+        if d.join("pnpm-lock.yaml").is_file() {
+            return "pnpm";
+        } else if d.join("yarn.lock").is_file() {
+            return "yarn";
+        } else if d.join("bun.lockb").is_file() || d.join("bun.lock").is_file() {
+            return "bun";
+        } else if d.join("package-lock.json").is_file() {
+            return "npm";
+        }
+    }
+    "npm"
 }

 fn has_build_script(dir: &Path) -> bool {
@@ -779,7 +687,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), None)?;
+    let mut plan = plan(root, model, kind, Some(module))?;
    if plan.system == BuildSystem::Maven && !test {
        for step in &mut plan.steps {
            if let Some(goal) = step.args.last_mut() {
@@ -844,153 +752,6 @@ fn launch_class_dirs(system: BuildSystem, module: &Path, test: bool) -> Vec<Path

 #[cfg(test)]
 mod tests {
-    #[test]
-    fn go_workspace_build_commands_compile_members_with_local_dependencies() {
-        let Some(go) = ide_core::process::find_executable("go", &ide_core::tool_path::search_path()) else {
-            return;
-        };
-        let tmp = tempfile::tempdir().unwrap();
-        let root = &tmp.path().join("workspace");
-        write(root, "go.work", "go 1.22\nuse (\n ./app\n ./lib\n ../external\n)\n");
-        write(root, "lib/go.mod", "module example.com/lib\ngo 1.22\n");
-        write(root, "lib/lib.go", "package lib\nfunc Value() int { return 1 }\n");
-        write(root, "app/go.mod", "module example.com/app\ngo 1.22\nrequire example.com/lib v0.0.0\n");
-        write(root, "app/main.go", "package main\nimport \"example.com/lib\"\nfunc main(){_ = lib.Value()}\n");
-        write(root, "../external/go.mod", "module example.com/external\ngo 1.22\nrequire example.com/lib v0.0.0\n");
-        write(root, "../external/main.go", "package main\nimport \"example.com/lib\"\nfunc main(){_ = lib.Value()}\n");
-        // std canonicalization also exercises verbatim paths on Windows.
-        for root in [root.to_path_buf(), std::fs::canonicalize(root).unwrap()] {
-            let plan = plan(&root, &BuildModel::default(), BuildKind::Build, None, None).unwrap();
-            for step in plan.steps {
-                let result = std::process::Command::new(&go)
-                    .args(&step.args)
-                    .envs(&step.env)
-                    .env("GOPROXY", "off")
-                    .current_dir(&step.cwd)
-                    .output()
-                    .unwrap();
-                assert!(result.status.success(), "{step:?}: {}", String::from_utf8_lossy(&result.stderr));
-            }
-        }
-    }
-
-    #[test]
-    fn go_workspace_builds_every_use_module() {
-        let tmp = tempfile::tempdir().unwrap();
-        let root = tmp.path().join("workspace");
-        write(&root, "go.work", "go 1.22\nuse (\n  ./api\n  \"./lib with spaces\"\n  ../shared\n)\n");
-        for module in ["api", "lib with spaces", "../shared"] {
-            write(&root.join(module), "go.mod", "module example.com/p\ngo 1.22\n");
-        }
-        // Cover native paths, Windows verbatim paths and non-normalized module paths.
-        let canonical = std::fs::canonicalize(&root).unwrap();
-        for root in [&root, &canonical, &canonical.join("..").join("workspace")] {
-            for kind in [BuildKind::Build, BuildKind::Rebuild, BuildKind::Artifacts] {
-                let p = plan(root, &BuildModel::default(), kind, None, None).unwrap();
-                assert_eq!(p.system, BuildSystem::Go);
-                assert_eq!(p.steps.len(), 3);
-                for (step, module) in p.steps.iter().zip(["api", "lib with spaces", "../shared"]) {
-                    assert_eq!(step.cwd, dunce::canonicalize(root.join(module)).unwrap());
-                    assert_eq!(
-                        step.env["GOWORK"],
-                        dunce::canonicalize(root.join("go.work")).unwrap().to_string_lossy()
-                    );
-                    let expected =
-                        if kind == BuildKind::Rebuild { vec!["build", "-a", "./..."] } else { vec!["build", "./..."] };
-                    assert_eq!(step.args, expected);
-                }
-            }
-        }
-        let member =
-            plan(&root, &BuildModel::default(), BuildKind::Build, Some(&root.join("api/pkg/a.go")), None).unwrap();
-        assert_eq!(member.steps.len(), 1);
-        assert_eq!(member.steps[0].cwd, root.join("api"));
-        assert_eq!(member.steps[0].args, ["build", "./pkg/..."]);
-        write(&root, "go.work", "use ./missing\n");
-        assert!(
-            plan(&root, &BuildModel::default(), BuildKind::Build, None, None)
-                .unwrap_err()
-                .to_string()
-                .contains("go.mod")
-        );
-        write(&root, "go.work", "go 1.22\n");
-        assert!(plan(&root, &BuildModel::default(), BuildKind::Build, None, None).is_err());
-    }
-
-    #[test]
-    fn independent_gradle_builds_keep_their_launchers_and_task_paths() {
-        let wrapper = if cfg!(windows) { "gradlew.bat" } else { "gradlew" };
-        let temp = tempfile::tempdir().unwrap();
-        let root = temp.path();
-        for dir in ["a", "b"] {
-            std::fs::create_dir_all(root.join(dir).join("app/src/main/java")).unwrap();
-            std::fs::write(root.join(dir).join("settings.gradle"), "include 'app'").unwrap();
-            std::fs::write(root.join(dir).join("app/build.gradle"), "plugins { id 'java' }").unwrap();
-            std::fs::write(root.join(dir).join(wrapper), "").unwrap();
-        }
-        let settings = ide_core::settings::GradleSettings {
-            linked_projects: Some(vec!["a".into(), "b".into()]),
-            ..Default::default()
-        };
-        let mut model = crate::load_linked(root, &root.join("cache"), None, &Default::default(), &settings);
-        model.gradle[0].env.insert("JAVA_HOME".into(), "/jdk-a".into());
-        model.gradle[1].env.insert("JAVA_HOME".into(), "/jdk-b".into());
-        let all = super::plan(root, &model, super::BuildKind::Build, None, None).unwrap();
-        assert_eq!(all.steps.len(), 2);
-        assert_eq!(all.steps[0].cwd, root.join("a"));
-        assert_eq!(all.steps[1].cwd, root.join("b"));
-        let module = super::plan(root, &model, super::BuildKind::Rebuild, Some(&root.join("b/app")), None).unwrap();
-        assert_eq!(module.steps.len(), 1);
-        assert_eq!(module.steps[0].program, root.join("b").join(wrapper).to_string_lossy());
-        assert_eq!(module.steps[0].cwd, root.join("b"));
-        assert_eq!(module.steps[0].env["JAVA_HOME"], "/jdk-b");
-        assert_eq!(module.steps[0].args, ["--console=plain", ":app:clean", ":app:classes", ":app:testClasses"]);
-        // A directly linked build owns its module even when another composite reports it too.
-        let direct = model.gradle[1].projects[0].clone();
-        model.gradle[0].projects.push(direct);
-        assert_eq!(model.gradle_for_module(root, &root.join("b")).unwrap().dir, "b");
-        let mut nested = model.gradle[1].projects[1].clone();
-        nested.path = ":b:app".into();
-        model.gradle[0].projects.push(nested);
-        let nested = super::plan(root, &model, super::BuildKind::Build, Some(&root.join("b/app")), None).unwrap();
-        assert_eq!(nested.steps[0].program, root.join("b").join(wrapper).to_string_lossy());
-        assert_eq!(nested.steps[0].args, ["--console=plain", ":app:classes", ":app:testClasses"]);
-        model.gradle.clear();
-        assert!(super::plan(root, &model, super::BuildKind::Build, Some(&root.join("b/app")), None).is_err());
-    }
-
-    #[test]
-    fn absolute_linked_roots_build_the_project_and_external_source_module() {
-        let wrapper = if cfg!(windows) { "gradlew.bat" } else { "gradlew" };
-        let temp = tempfile::tempdir().unwrap();
-        let base = dunce::canonicalize(temp.path()).unwrap();
-        let root = base.join("workspace");
-        let external = base.join("external");
-        std::fs::create_dir(&root).unwrap();
-        std::fs::create_dir_all(external.join("app/src/main/java")).unwrap();
-        std::fs::write(external.join("settings.gradle"), "include 'app'").unwrap();
-        let source = external.join("app/src/main/java/App.java");
-        std::fs::write(&source, "class App {}").unwrap();
-        std::fs::write(external.join(wrapper), "").unwrap();
-        let settings = ide_core::settings::GradleSettings {
-            linked_projects: Some(vec![external.to_string_lossy().into_owned()]),
-            ..Default::default()
-        };
-        let mut model = crate::load_linked(&root, &base.join("cache"), None, &Default::default(), &settings);
-        model.gradle[0].env.insert("JAVA_HOME".into(), "/external-jdk".into());
-        let all = super::plan(&root, &model, super::BuildKind::Build, None, None).unwrap();
-        assert_eq!(all.steps[0].cwd, external);
-        // Linked roots are saved with forward slashes, so on Windows the program mixes separators.
-        assert_eq!(std::path::Path::new(&all.steps[0].program), external.join(wrapper));
-        let module = super::plan(&root, &model, super::BuildKind::Rebuild, Some(&source), None).unwrap();
-        assert_eq!(module.steps[0].cwd, external);
-        assert_eq!(module.steps[0].env["JAVA_HOME"], "/external-jdk");
-        assert_eq!(module.steps[0].args, ["--console=plain", ":app:clean", ":app:classes", ":app:testClasses"]);
-        let other = base.join("unlinked");
-        std::fs::create_dir(&other).unwrap();
-        std::fs::write(other.join("build.gradle"), "").unwrap();
-        assert!(super::plan(&root, &model, super::BuildKind::Build, Some(&other), None).is_err());
-    }
    use super::*;

    /// Launch outputs use the platform separator throughout, so they compare equal to
@@ -1035,12 +796,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, None).unwrap();
+        let p = plan(&root, &model, BuildKind::Build, 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")), None).unwrap();
+        let p = plan(&root, &model, BuildKind::Rebuild, Some(&root.join("core/src/main/java/A.java"))).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'");
@@ -1049,24 +810,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")), None).unwrap();
+        let p = plan(&g, &model, BuildKind::Build, Some(&g.join("app/src/A.java"))).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, None).unwrap().steps[0].args,
+            plan(&g, &model, BuildKind::Artifacts, 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, None).unwrap();
+        let p = plan(&c, &BuildModel::default(), BuildKind::Rebuild, 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")), None).unwrap();
+        let p = plan(&go, &BuildModel::default(), BuildKind::Build, Some(&go.join("pkg/a/a.go"))).unwrap();
        assert_eq!(p.steps[0].args, ["build", "./pkg/a/..."]);
        assert_eq!(p.steps[0].cwd, go);

@@ -1074,51 +835,19 @@ 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, None).unwrap();
+        let p = plan(&ts, &BuildModel::default(), BuildKind::Build, None).unwrap();
        assert_eq!(p.steps[0].args, ["--noEmit", "--pretty", "false", "-p", "."]);
-        let p = plan(&ts, &BuildModel::default(), BuildKind::Artifacts, None, None).unwrap();
+        let p = plan(&ts, &BuildModel::default(), BuildKind::Artifacts, 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, None).unwrap();
+        let p = plan(&siblings, &model, BuildKind::Build, None).unwrap();
        assert_eq!(p.system, BuildSystem::Maven);
        assert_eq!(
            p.steps.iter().map(|s| s.cwd.clone()).collect::<Vec<_>>(),
@@ -1127,7 +856,7 @@ mod tests {

        let none = tmp.path().join("none");
        std::fs::create_dir_all(&none).unwrap();
-        assert!(plan(&none, &BuildModel::default(), BuildKind::Build, None, None).is_err());
+        assert!(plan(&none, &BuildModel::default(), BuildKind::Build, None).is_err());
    }

    #[test]
@@ -22,8 +22,6 @@ 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.
@@ -298,17 +296,6 @@ 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" {
@@ -423,7 +410,6 @@ 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 {
@@ -577,24 +563,6 @@ 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(
@@ -218,14 +218,21 @@ fn normalize(p: &Path) -> PathBuf {
    out
 }

-/// The first automatically discovered build, for callers operating on one build.
+/// The directory of the Gradle build under `root`: the root itself, or a direct
+/// subfolder, holding a settings or build script.
 pub fn build_dir(root: &Path) -> Option<PathBuf> {
-    build_dirs(root).into_iter().next()
-}
-
-fn build_dirs(root: &Path) -> Vec<PathBuf> {
-    let markers: Vec<_> = SETTINGS_FILES.iter().chain(BUILD_FILES).copied().collect();
-    ide_core::project_roots::discover(root, &markers)
+    let has = |d: &Path| SETTINGS_FILES.iter().chain(BUILD_FILES).any(|f| d.join(f).is_file());
+    if has(root) {
+        return Some(root.to_path_buf());
+    }
+    let mut dirs: Vec<PathBuf> = std::fs::read_dir(root)
+        .ok()?
+        .flatten()
+        .filter(|e| e.file_type().is_ok_and(|t| t.is_dir()) && !e.file_name().to_string_lossy().starts_with('.'))
+        .map(|e| e.path())
+        .collect();
+    dirs.sort();
+    dirs.into_iter().find(|d| SETTINGS_FILES.iter().any(|f| d.join(f).is_file()))
 }

 fn wrapper(dir: &Path) -> String {
@@ -428,17 +435,6 @@ pub fn external_roots<'a>(root: &Path, dirs: impl IntoIterator<Item = &'a str>)

 pub fn load(root: &Path) -> Option<GradleModel> {
    let dir = build_dir(root)?;
-    load_build(root, dir.strip_prefix(root).unwrap_or(&dir))
-}
-
-/// Loads exactly this build, without searching its child folders.
-pub fn load_build(root: &Path, dir: &Path) -> Option<GradleModel> {
-    // Linked builds are saved with forward slashes; rebuild the path so the launcher
-    // and module folders use the platform's separators.
-    let dir: PathBuf = root.join(dir).components().collect();
-    if !SETTINGS_FILES.iter().chain(BUILD_FILES).any(|name| dir.join(name).is_file()) {
-        return None;
-    }
    let settings = read_first(&dir, SETTINGS_FILES).map(|(_, t)| parse_settings(&t)).unwrap_or_default();
    let root_name =
        settings.name.unwrap_or_else(|| dir.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default());
@@ -459,65 +455,6 @@ pub fn load_build(root: &Path, dir: &Path) -> Option<GradleModel> {
    Some(GradleModel { dir: rel(root, &dir), projects, java_version, command: wrapper(&dir), ..GradleModel::default() })
 }

-/// Validates user-selected build folders and stores a stable, deduplicated identity.
-pub fn normalize_linked_projects(root: &Path, dirs: &[String]) -> ide_core::IdeResult<Vec<String>> {
-    let root = dunce::canonicalize(root)?;
-    let mut out = Vec::new();
-    for dir in dirs {
-        let path = dunce::canonicalize(root.join(dir))?;
-        if !path.is_dir() || !SETTINGS_FILES.iter().chain(BUILD_FILES).any(|name| path.join(name).is_file()) {
-            return Err(ide_core::IdeError::invalid(format!("No Gradle build in {}", path.display())));
-        }
-        let dir = rel(&root, &path);
-        if !out.contains(&dir) {
-            out.push(dir);
-        }
-    }
-    Ok(out)
-}
-
-/// The form `normalize_linked_projects` saves `dir` in, also for a folder that no longer
-/// exists, so a path the UI sends (`C:\…` on Windows) matches the saved entry.
-pub fn linked_project_key(root: &Path, dir: &str) -> String {
-    match (dunce::canonicalize(root), dunce::canonicalize(root.join(dir))) {
-        (Ok(root), Ok(path)) => rel(&root, &path),
-        _ => dir.replace('\\', "/"),
-    }
-}
-
-/// Linked build identities without reading their scripts (also used by index hot paths).
-pub(crate) fn linked_dirs(root: &Path, settings: &ide_core::settings::GradleSettings) -> Vec<String> {
-    match &settings.linked_projects {
-        None => build_dirs(root).iter().map(|dir| rel(root, dir)).collect(),
-        Some(dirs) => {
-            let mut out = Vec::new();
-            for dir in dirs {
-                if let Ok(dirs) = normalize_linked_projects(root, std::slice::from_ref(dir)) {
-                    for dir in dirs {
-                        if !out.contains(&dir) {
-                            out.push(dir);
-                        }
-                    }
-                }
-            }
-            out
-        }
-    }
-}
-
-pub fn load_linked(root: &Path, settings: &ide_core::settings::GradleSettings) -> Vec<GradleModel> {
-    linked_dirs(root, settings).iter().filter_map(|dir| load_build(root, Path::new(dir))).collect()
-}
-
-/// A build's task paths are local to it, so sync caches must be local to its identity too.
-pub fn cache_dir(cache: &Path, build_dir: &str) -> PathBuf {
-    if build_dir.is_empty() {
-        return cache.to_path_buf();
-    }
-    let hash = build_dir.bytes().fold(0xcbf29ce484222325u64, |h, b| (h ^ u64::from(b)).wrapping_mul(0x100000001b3));
-    cache.join("gradle").join(format!("{hash:016x}"))
-}
-
 /// `JavaLanguageVersion.of(21)` / `sourceCompatibility = JavaVersion.VERSION_17` in a build script.
 pub fn script_java_version(text: &str) -> Option<u32> {
    let number = |s: &str| -> Option<u32> {
@@ -679,117 +616,6 @@ pub(crate) fn has_war_plugin(script: &str) -> bool {

 #[cfg(test)]
 mod tests {
-    #[test]
-    fn default_linkage_discovers_all_shallow_builds() {
-        let temp = tempfile::tempdir().unwrap();
-        let root = temp.path();
-        for file in [
-            "Cargo.toml",
-            "package.json",
-            "fixtures/kotlin-gradle/settings.gradle.kts",
-            "fixtures/kotlin-gradle/build.gradle.kts",
-            "fixtures/kotlin-gradle/tools/settings.gradle",
-            "services/backend/api/settings.gradle",
-            "standalone/build.gradle",
-            "ignored/src/settings.gradle",
-            "ignored/out/build.gradle",
-            "node_modules/example/settings.gradle",
-            "target/example/build.gradle",
-            "build/example/settings.gradle",
-            "dist/example/build.gradle",
-            "vendor/example/settings.gradle",
-            ".hidden/settings.gradle",
-            "too/deep/to/find/settings.gradle",
-        ] {
-            let path = root.join(file);
-            std::fs::create_dir_all(path.parent().unwrap()).unwrap();
-            std::fs::write(path, "").unwrap();
-        }
-        let models = super::load_linked(root, &Default::default());
-        assert_eq!(
-            models.iter().map(|m| m.dir.as_str()).collect::<Vec<_>>(),
-            ["fixtures/kotlin-gradle", "ignored/src", "services/backend/api", "standalone"]
-        );
-        std::fs::write(root.join("build.gradle.kts"), "").unwrap();
-        let models = super::load_linked(root, &Default::default());
-        assert_eq!(models.len(), 1);
-        assert!(models[0].dir.is_empty());
-    }
-
-    #[cfg(unix)]
-    #[test]
-    fn default_linkage_does_not_follow_symlinks() {
-        let temp = tempfile::tempdir().unwrap();
-        let root = temp.path();
-        std::fs::create_dir(root.join("real")).unwrap();
-        std::fs::write(root.join("real/build.gradle"), "").unwrap();
-        std::os::unix::fs::symlink(root.join("real"), root.join("alias")).unwrap();
-        let models = super::load_linked(root, &Default::default());
-        assert_eq!(models.iter().map(|m| m.dir.as_str()).collect::<Vec<_>>(), ["real"]);
-    }
-
-    #[test]
-    fn a_path_from_the_ui_finds_the_saved_link() {
-        let temp = tempfile::tempdir().unwrap();
-        let root = temp.path().join("workspace");
-        let external = temp.path().join("external");
-        for dir in [root.join("a"), external.clone()] {
-            std::fs::create_dir_all(&dir).unwrap();
-            std::fs::write(dir.join("settings.gradle"), "").unwrap();
-        }
-        let native = |p: &std::path::Path| p.to_string_lossy().into_owned();
-        // Saved by linking; unlinking may send a native, absolute or non-canonical spelling.
-        for (dir, sent) in [
-            ("a", native(&root.join("a"))),
-            ("a", "a".to_owned()),
-            ("a", native(&root.join("a").join("..").join("a"))),
-            ("../external", native(&external)),
-        ] {
-            let saved = super::normalize_linked_projects(&root, &[dir.into()]).unwrap();
-            assert_eq!(super::linked_project_key(&root, &sent), saved[0], "{sent}");
-        }
-        // A folder deleted since it was linked still matches its saved entry.
-        assert_eq!(super::linked_project_key(&root, r"gone\build"), "gone/build");
-    }
-
-    #[test]
-    fn explicit_linkage_preserves_default_discovery_and_can_unlink_every_build() {
-        let temp = tempfile::tempdir().unwrap();
-        let root = temp.path();
-        for dir in ["a", "b"] {
-            std::fs::create_dir(root.join(dir)).unwrap();
-            std::fs::write(root.join(dir).join("settings.gradle"), format!("rootProject.name = '{dir}'")).unwrap();
-        }
-        assert_eq!(
-            super::load_linked(root, &Default::default()).iter().map(|m| m.dir.as_str()).collect::<Vec<_>>(),
-            ["a", "b"]
-        );
-        let mut settings = ide_core::settings::GradleSettings {
-            linked_projects: Some(vec!["b".into(), "./b".into(), "a".into()]),
-            ..Default::default()
-        };
-        let models = super::load_linked(root, &settings);
-        assert_eq!(models.iter().map(|g| g.dir.as_str()).collect::<Vec<_>>(), ["b", "a"]);
-        settings.linked_projects = Some(vec![]);
-        assert!(super::load_linked(root, &settings).is_empty());
-        assert!(super::normalize_linked_projects(root, &["missing".into()]).is_err());
-        assert!(super::normalize_linked_projects(root, &["".into()]).is_err());
-        assert!(super::load_build(root, root).is_none(), "exact loading never picks a child");
-    }
-
-    #[cfg(unix)]
-    #[test]
-    fn linked_directories_deduplicate_symlinks_and_keep_external_builds() {
-        let temp = tempfile::tempdir().unwrap();
-        let root = temp.path().join("workspace");
-        let external = temp.path().join("external");
-        std::fs::create_dir(&root).unwrap();
-        std::fs::create_dir(&external).unwrap();
-        std::fs::write(external.join("build.gradle"), "").unwrap();
-        std::os::unix::fs::symlink(&external, root.join("alias")).unwrap();
-        let dirs = super::normalize_linked_projects(&root, &["alias".into(), "../external".into()]).unwrap();
-        assert_eq!(dirs, [external.canonicalize().unwrap().to_string_lossy().to_string()]);
-    }
    #[test]
    fn script_dependencies_read_string_and_map_notations() {
        let script = r#"
@@ -1,268 +0,0 @@
-//! 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,
-    model: &gradle::GradleModel,
-    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 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(), &Default::default(), &options, ":", "x --init-script y", &cancel).is_err()
-        );
-        assert!(
-            gradle_dependencies(tmp.path(), &Default::default(), &options, "app", "runtimeClasspath", &cancel).is_err()
-        );
-    }
-
-    #[cfg(unix)]
-    #[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,
-            &gradle::load(root).unwrap(),
-            &options,
-            ":app",
-            "testRuntimeClasspath",
-            &CancellationToken::new(),
-        )
-        .unwrap();
-        assert_eq!(tree, vec![dep("org.a", "b", Some("1.0"))]);
-        assert_eq!(
-            std::fs::read_to_string(root.join("args")).unwrap().trim(),
-            "--console=plain -q :app:dependencies --configuration testRuntimeClasspath --offline"
-        );
-    }
-}
@@ -53,12 +53,8 @@ pub struct Outcome {
    pub success: bool,
 }

-/// Only linked Maven modules contribute sources to the bridge.
-pub fn has_kotlin(root: &Path, model: &BuildModel) -> bool {
-    model.maven.iter().flat_map(|m| &m.projects).any(|p| has_kotlin_sources(&root.join(&p.dir)))
-}
-
-fn has_kotlin_sources(root: &Path) -> bool {
+/// Inspect sources, excluding generated/build/VCS trees and never following symlinks.
+pub fn has_kotlin(root: &Path) -> bool {
    let Ok(entries) = std::fs::read_dir(root) else { return false };
    entries.flatten().any(|entry| {
        let Ok(kind) = entry.file_type() else { return false };
@@ -70,25 +66,11 @@ fn has_kotlin_sources(root: &Path) -> bool {
                    entry.file_name().to_str(),
                    Some("target" | "build" | "out" | "bin" | "node_modules" | ".git" | ".openidea")
                )
-                && !["pom.xml", "build.gradle", "build.gradle.kts", "settings.gradle", "settings.gradle.kts"]
-                    .iter()
-                    .any(|marker| entry.path().join(marker).is_file())
-                && has_kotlin_sources(&entry.path())
+                && has_kotlin(&entry.path())
        }
    })
 }

-fn plan(root: &Path, model: &BuildModel) -> IdeResult<compile::BuildPlan> {
-    if model.maven.as_ref().is_none_or(|m| m.projects.is_empty()) {
-        return Err(IdeError::invalid("Kotlin bridge requires a Maven build root"));
-    }
-    Ok(compile::BuildPlan {
-        system: compile::BuildSystem::Maven,
-        title: root.file_name().unwrap_or_default().to_string_lossy().into_owned(),
-        steps: compile::maven_steps(root, model, BuildKind::Build, None)?,
-    })
-}
-
 /// Run the project's configured wrapper/settings/JDK and lifecycle, with an output
 /// redirector loaded before Maven calculates its lifecycle execution plans.
 pub fn build(
@@ -99,7 +81,10 @@ pub fn build(
    cancel: &CancellationToken,
 ) -> IdeResult<Outcome> {
    std::fs::create_dir_all(generation)?;
-    let mut plan = plan(root, model)?;
+    let mut plan = compile::plan(root, model, BuildKind::Build, None)?;
+    if plan.system != compile::BuildSystem::Maven {
+        return Err(IdeError::invalid("Kotlin bridge requires a Maven build root"));
+    }
    let mut manifests = Vec::new();
    for (index, step) in plan.steps.iter_mut().enumerate() {
        step.args.push("--fail-at-end".into());
@@ -462,106 +447,14 @@ mod tests {
        assert_eq!(error.message, "Kotlin bridge requires a Maven build root");
    }

-    #[test]
-    fn kotlin_sources_belong_to_linked_maven_modules() {
-        let dir = tempfile::tempdir().unwrap();
-        let root = dir.path();
-        for file in [
-            "java/pom.xml",
-            "gradle/build.gradle.kts",
-            "gradle/src/main/kotlin/App.kt",
-            "java/unlinked/pom.xml",
-            "java/unlinked/src/main/kotlin/App.kt",
-            "java/gradle/settings.gradle.kts",
-            "java/gradle/src/main/kotlin/App.kt",
-            "java/target/generated/Old.kt",
-            "java/node_modules/dependency/App.kt",
-            "java/linked/pom.xml",
-            "java/linked/src/test/kotlin/Test.kt",
-        ] {
-            let path = root.join(file);
-            std::fs::create_dir_all(path.parent().unwrap()).unwrap();
-            std::fs::write(path, "").unwrap();
-        }
-        let mut model = BuildModel {
-            maven: Some(crate::MavenModel {
-                projects: vec![crate::MavenProject { dir: "java".into(), ..Default::default() }],
-                ..Default::default()
-            }),
-            ..Default::default()
-        };
-        assert!(!has_kotlin(root, &model));
-        model.maven.as_mut().unwrap().projects.push(crate::MavenProject {
-            dir: "java/linked".into(),
-            aggregated: true,
-            ..Default::default()
-        });
-        assert!(has_kotlin(root, &model));
-        model.maven.as_mut().unwrap().projects.clear();
-        assert!(!has_kotlin(root, &model));
-        assert!(!has_kotlin(root, &BuildModel::default()));
-    }
-
-    #[test]
-    fn maven_bridge_ignores_the_workspace_build_system() {
-        for marker in ["Cargo.toml", "package.json", "build.gradle.kts", "go.mod", "CMakeLists.txt"] {
-            let dir = tempfile::tempdir().unwrap();
-            let root = dir.path();
-            std::fs::write(root.join(marker), "").unwrap();
-            let mut model = BuildModel { maven: Some(crate::MavenModel::default()), ..Default::default() };
-            for name in ["java", "kotlin"] {
-                let module = root.join(name);
-                std::fs::create_dir_all(&module).unwrap();
-                model.maven.as_mut().unwrap().projects.push(crate::MavenProject {
-                    dir: name.into(),
-                    command: format!("{name}-mvnw"),
-                    options: vec!["-o".into(), "-Peditor".into()],
-                    env: BTreeMap::from([("JAVA_HOME".into(), "/jdk".into())]),
-                    ..Default::default()
-                });
-            }
-            std::fs::write(root.join("kotlin/App.kt"), "class App").unwrap();
-            assert!(has_kotlin(root, &model), "{marker}");
-            let plan = plan(root, &model).unwrap();
-            assert_eq!(plan.system, compile::BuildSystem::Maven);
-            assert_eq!(plan.steps.len(), 2);
-            for (step, name) in plan.steps.iter().zip(["java", "kotlin"]) {
-                assert_eq!(step.cwd, root.join(name));
-                assert_eq!(step.program, format!("{name}-mvnw"));
-                assert_eq!(step.args, ["-B", "-Dstyle.color=never", "-o", "-Peditor", "test-compile"]);
-                assert_eq!(step.env.get("JAVA_HOME").map(String::as_str), Some("/jdk"));
-            }
-        }
-    }
-
-    #[test]
-    fn external_linked_maven_sources_are_included() {
-        let workspace = tempfile::tempdir().unwrap();
-        let external = tempfile::tempdir().unwrap();
-        std::fs::write(external.path().join("App.kt"), "class App").unwrap();
-        let model = BuildModel {
-            maven: Some(crate::MavenModel {
-                projects: vec![crate::MavenProject {
-                    dir: external.path().to_string_lossy().into_owned(),
-                    command: "mvn".into(),
-                    ..Default::default()
-                }],
-                ..Default::default()
-            }),
-            ..Default::default()
-        };
-        assert!(has_kotlin(workspace.path(), &model));
-        assert_eq!(plan(workspace.path(), &model).unwrap().steps[0].cwd, external.path());
-    }
-
    #[test]
    fn does_not_find_deleted_sources_in_build_outputs() {
        let dir = tempfile::tempdir().unwrap();
        std::fs::create_dir_all(dir.path().join("target/generated")).unwrap();
        std::fs::write(dir.path().join("target/generated/Old.kt"), "").unwrap();
-        assert!(!has_kotlin_sources(dir.path()));
+        assert!(!has_kotlin(dir.path()));
        std::fs::write(dir.path().join("New.kt"), "").unwrap();
-        assert!(has_kotlin_sources(dir.path()));
+        assert!(has_kotlin(dir.path()));
    }

    #[test]
@@ -8,7 +8,6 @@
 pub mod application_update;
 pub mod compile;
 pub mod gradle;
-mod gradle_deps;
 pub mod kotlin_bridge;
 pub mod maven;
 pub mod pom_edit;
@@ -18,11 +17,8 @@ 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_gradle_model, sync_maven,
-};
+pub use sync::{SyncOptions, SyncProgress, maven_profiles, save_maven_profiles, sync_gradle, sync_maven};

 use serde::{Deserialize, Serialize};
 use specta::Type;
@@ -40,31 +36,13 @@ pub enum BuildTool {
 #[serde(rename_all = "camelCase")]
 pub struct BuildModel {
    pub maven: Option<MavenModel>,
-    #[serde(default)]
-    pub gradle: Vec<GradleModel>,
-}
-
-impl BuildModel {
-    /// Prefer the deepest linked build owning the module over a composite including it.
-    pub fn gradle_for_module(&self, root: &Path, module: &Path) -> Option<&GradleModel> {
-        let module = root.join(module);
-        self.gradle.iter().filter(|g| g.projects.iter().any(|p| root.join(&p.dir) == module)).min_by_key(|g| {
-            let dir = root.join(&g.dir);
-            std::cmp::Reverse(if module.starts_with(&dir) { dir.components().count() } else { 0 })
-        })
-    }
+    pub gradle: Option<GradleModel>,
 }

 /// Static model of the builds under `root`, merged with the sync results cached in `cache_dir`.
 /// Parent POMs are looked up in `maven_repo` (the configured local repository), else the default one.
 pub fn load(root: &Path, cache_dir: &Path, maven_repo: Option<PathBuf>) -> BuildModel {
-    load_linked(
-        root,
-        cache_dir,
-        maven_repo,
-        &ide_core::settings::MavenSettings::default(),
-        &ide_core::settings::GradleSettings::default(),
-    )
+    load_linked(root, cache_dir, maven_repo, &ide_core::settings::MavenSettings::default())
 }

 /// Loads only linked Maven reactors, retaining an empty model so projects can be re-added.
@@ -73,66 +51,30 @@ pub fn load_linked(
    cache_dir: &Path,
    maven_repo: Option<PathBuf>,
    settings: &ide_core::settings::MavenSettings,
-    gradle_settings: &ide_core::settings::GradleSettings,
 ) -> BuildModel {
-    let maven = maven::has_projects(root, settings).then(|| {
-        let profiles = sync::maven_profiles(cache_dir);
-        let repo = maven_repo.or_else(maven::default_local_repo);
-        let mut m = maven::load_with_linked(root, repo, &profiles, &settings.linked_projects);
+    let maven = maven::is_maven_project(root).then(|| {
+        let mut m = maven::load_with_repo(root, maven_repo.or_else(maven::default_local_repo));
        maven::UnlinkedProjects::from_model(&m, settings).filter(&mut m);
-        // The user settings' profiles can be chosen too (`-P` applies to them as well).
-        for p in maven::user_settings_file(root, settings).map(|f| maven::settings_profiles(&f)).unwrap_or_default() {
-            if !m.profiles.iter().any(|x| x.id == p.id) {
-                m.profiles.push(p);
-            }
-        }
        sync::apply_maven_cache(root, cache_dir, &mut m);
        m
    });
-    let gradle = gradle::load_linked(root, gradle_settings)
-        .into_iter()
-        .map(|mut g| {
-            sync::apply_gradle_cache(root, &gradle::cache_dir(cache_dir, &g.dir), &mut g);
-            g
-        })
-        .collect();
+    let gradle = gradle::load(root).map(|mut g| {
+        sync::apply_gradle_cache(root, cache_dir, &mut g);
+        g
+    });
    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,
-    settings: &ide_core::settings::GradleSettings,
-) -> Vec<PathBuf> {
-    let builds = gradle::linked_dirs(root, settings);
-    let dirs: Vec<String> = builds
-        .iter()
-        .flat_map(|dir| {
-            std::iter::once(root.join(dir).to_string_lossy().into_owned()).chain(
-                sync::reported_gradle_projects(&gradle::cache_dir(cache_dir, dir))
-                    .iter()
-                    .map(|p| p.dir.clone())
-                    .collect::<Vec<_>>(),
-            )
-        })
-        .collect();
-    gradle::external_roots(root, dirs.iter().map(String::as_str))
+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(
-    root: &Path,
-    cache_dir: &Path,
-    settings: &ide_core::settings::GradleSettings,
-) -> Vec<(PathBuf, gradle::ReportedRoot)> {
-    let reported = gradle::linked_dirs(root, settings)
-        .iter()
-        .flat_map(|dir| sync::reported_gradle_projects(&gradle::cache_dir(cache_dir, dir)).as_ref().clone())
-        .collect::<Vec<_>>();
-    gradle::reported_source_roots(&reported)
+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`.
@@ -176,7 +118,7 @@ pub fn dependency_coordinates(root: &Path, model: &BuildModel) -> Vec<Dependency
            });
        }
    }
-    for g in &model.gradle {
+    if let Some(g) = &model.gradle {
        for script in g.projects.iter().filter_map(|p| p.build_file.as_ref()) {
            let Ok(text) = std::fs::read_to_string(root.join(script)) else { continue };
            out.extend(gradle::script_dependencies(&text).into_iter().map(|(group_id, artifact_id, version)| {
@@ -202,26 +144,6 @@ pub fn affects_build(rel: &Path) -> bool {
 mod tests {
    use super::*;

-    #[test]
-    fn external_linked_build_is_indexed_before_sync_and_disappears_when_unlinked() {
-        let temp = tempfile::tempdir().unwrap();
-        let root = temp.path().join("workspace");
-        let external = temp.path().join("external");
-        std::fs::create_dir(&root).unwrap();
-        std::fs::create_dir(&external).unwrap();
-        std::fs::write(external.join("settings.gradle"), "").unwrap();
-        let mut settings = ide_core::settings::GradleSettings {
-            linked_projects: Some(vec![external.to_string_lossy().into_owned()]),
-            ..Default::default()
-        };
-        assert_eq!(
-            gradle_external_roots(&root, &temp.path().join("cache"), &settings),
-            [dunce::canonicalize(&external).unwrap()]
-        );
-        settings.linked_projects = Some(vec![]);
-        assert!(gradle_external_roots(&root, &temp.path().join("cache"), &settings).is_empty());
-    }
-
    #[test]
    fn detects_build_systems_and_build_files() {
        let tmp = tempfile::tempdir().unwrap();
@@ -233,7 +155,7 @@ mod tests {
        std::fs::write(root.join("build.gradle"), "").unwrap();
        let m = load(&root, &cache, None);
        assert_eq!(m.maven.unwrap().projects[0].pom, "svc/pom.xml");
-        assert_eq!(m.gradle[0].projects[0].path, ":");
+        assert_eq!(m.gradle.unwrap().projects[0].path, ":");
        assert!(affects_build(Path::new("a/pom.xml")) && affects_build(Path::new("settings.gradle.kts")));
        assert!(!affects_build(Path::new("src/Main.java")));
    }
@@ -280,7 +202,7 @@ mod tests {
            ],
            ..Default::default()
        };
-        let gradle = gradle::load(root).into_iter().collect();
+        let gradle = gradle::load(root);
        let model = BuildModel { maven: Some(maven), gradle };
        let names: Vec<String> = dependency_coordinates(root, &model)
            .into_iter()
@@ -8,7 +8,6 @@
 //! later replaces plugins and dependencies with the effective build.

 use crate::xml::{self, Element};
-use ide_core::{Pos, Range};
 use serde::{Deserialize, Serialize};
 use specta::Type;
 use std::collections::{BTreeMap, HashMap, HashSet};
@@ -461,53 +460,16 @@ 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>,
 }

 /// `~/.m2/repository`, or `<localRepository>` from `~/.m2/settings.xml`.
-pub fn default_local_repo() -> Option<PathBuf> {
+pub(crate) fn default_local_repo() -> Option<PathBuf> {
    let m2 = dirs::home_dir()?.join(".m2");
    local_repository_of(&m2.join("settings.xml")).or(Some(m2.join("repository")))
 }

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

 impl Resolver {
-    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 new(local_repo: Option<PathBuf>) -> Self {
+        Self { local_repo, poms: HashMap::new(), contexts: HashMap::new() }
    }

    fn pom(&mut self, path: &Path) -> Option<RawPom> {
@@ -596,7 +550,7 @@ impl Resolver {
        if pom.compiler_release.is_some() {
            ctx.compiler_release = pom.compiler_release.clone();
        }
-        for p in self.active(&pom.profiles) {
+        for p in pom.profiles.iter().filter(|p| p.active_by_default) {
            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);
@@ -712,7 +666,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);
@@ -1014,7 +968,10 @@ pub(crate) fn plugin(

 // ---------------------------------------------------------------- loading

+/// Directories never searched for POMs.
+const SKIP_DIRS: &[&str] = &["node_modules", "target", "build", "out", "dist", "src", "vendor"];
 const MAX_PROJECTS: usize = 1000;
+const POM_SEARCH_DEPTH: usize = 3;

 fn rel_path(root: &Path, p: &Path) -> String {
    p.strip_prefix(root).unwrap_or(p).to_string_lossy().replace('\\', "/")
@@ -1025,7 +982,44 @@ fn rel_path(root: &Path, p: &Path) -> String {
 /// aggregate POM directly inside `src/` counts too (issue #1001: `src/pom.xml`
 /// with its modules beside it, `src/app/pom.xml` and so on).
 fn top_level_poms(root: &Path) -> Vec<PathBuf> {
-    ide_core::project_roots::discover(root, &["pom.xml"]).into_iter().map(|dir| dir.join("pom.xml")).collect()
+    let top = root.join("pom.xml");
+    if top.is_file() {
+        return vec![top];
+    }
+    let mut out = Vec::new();
+    let src_pom = root.join("src").join("pom.xml");
+    if src_pom.is_file() {
+        out.push(src_pom);
+    }
+    let mut queue: Vec<(PathBuf, usize)> = vec![(root.to_path_buf(), 0)];
+    while let Some((dir, depth)) = queue.pop() {
+        let Ok(entries) = std::fs::read_dir(&dir) else { continue };
+        let mut dirs: Vec<PathBuf> = Vec::new();
+        for e in entries.flatten() {
+            let name = e.file_name().to_string_lossy().into_owned();
+            if e.file_type().is_ok_and(|t| t.is_dir()) && !name.starts_with('.') && !SKIP_DIRS.contains(&name.as_str())
+            {
+                dirs.push(e.path());
+            }
+        }
+        dirs.sort();
+        for d in dirs.into_iter().rev() {
+            let pom = d.join("pom.xml");
+            if pom.is_file() {
+                out.push(pom);
+                continue;
+            }
+            let src_pom = d.join("src").join("pom.xml");
+            if src_pom.is_file() {
+                out.push(src_pom);
+            }
+            if depth + 1 < POM_SEARCH_DEPTH {
+                queue.push((d, depth + 1));
+            }
+        }
+    }
+    out.sort();
+    out
 }

 /// Whether `root` holds a Maven build (cheap: the same search as [`load`] without parsing).
@@ -1061,77 +1055,12 @@ pub fn load(root: &Path) -> MavenModel {
    load_with_repo(root, default_local_repo())
 }

-/// [`load`] with the POMs `settings` link (Add Maven Projects).
-pub fn load_linked(root: &Path, settings: &ide_core::settings::MavenSettings) -> MavenModel {
-    load_with_linked(root, default_local_repo(), &[], &settings.linked_projects)
-}
-
 pub(crate) fn load_with_repo(root: &Path, local_repo: Option<PathBuf>) -> MavenModel {
-    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 {
-    load_with_linked(root, local_repo, profiles, &[])
-}
-
-/// The POMs of `linked` (project-relative, from Settings) that exist inside `root`.
-fn linked_poms(root: &Path, linked: &[String]) -> Vec<PathBuf> {
-    let base = dunce::canonicalize(root).unwrap_or_else(|_| root.to_path_buf());
-    let mut out: Vec<PathBuf> = Vec::new();
-    for pom in linked {
-        let pom = normalized_pom(pom);
-        if pom.is_empty() || pom.starts_with("../") || pom == ".." {
-            continue;
-        }
-        let path = root.join(&pom);
-        let inside = dunce::canonicalize(&path).is_ok_and(|p| p.starts_with(&base));
-        if path.is_file() && inside && !out.contains(&path) {
-            out.push(path);
-        }
-    }
-    out
-}
-
-/// Whether `root` holds a Maven build or the settings link one inside it.
-pub fn has_projects(root: &Path, settings: &ide_core::settings::MavenSettings) -> bool {
-    is_maven_project(root) || !linked_poms(root, &settings.linked_projects).is_empty()
-}
-
-/// The model with the chosen `profiles` (`-P` entries; `!id` deactivates: their modules,
-/// dependencies and properties are part of the model, those turned off are not) and the
-/// `linked` POMs (Add Maven Projects): builds that no reactor lists, shown as independent
-/// top-level projects. A linked POM that turns out to be a module of the root reactor stays that module.
-pub fn load_with_linked(
-    root: &Path,
-    local_repo: Option<PathBuf>,
-    profiles: &[String],
-    linked: &[String],
-) -> MavenModel {
-    let mut resolver = Resolver::new(local_repo, profiles);
+    let mut resolver = Resolver::new(local_repo);
    let mut model = MavenModel::default();
    let mut seen: HashSet<PathBuf> = HashSet::new();
-    let mut tops = top_level_poms(root);
-    for pom in linked_poms(root, linked) {
-        if !tops.contains(&pom) {
-            tops.push(pom);
-        }
-    }
-    // (pom, aggregated); the root reactor and its modules come before linked POMs.
-    let mut stack: Vec<(PathBuf, bool)> = tops.into_iter().rev().map(|p| (p, false)).collect();
+    // (pom, aggregated)
+    let mut stack: Vec<(PathBuf, bool)> = top_level_poms(root).into_iter().rev().map(|p| (p, false)).collect();
    while let Some((path, aggregated)) = stack.pop() {
        if model.projects.len() >= MAX_PROJECTS {
            break;
@@ -1147,7 +1076,7 @@ pub fn load_with_linked(
        let i = |s: &str| interpolate(s, &props);

        let mut module_names: Vec<String> = pom.modules.clone();
-        for p in resolver.active(&pom.profiles) {
+        for p in pom.profiles.iter().filter(|p| p.active_by_default) {
            module_names.extend(p.modules.iter().cloned());
        }
        let mut modules: Vec<PathBuf> = Vec::new();
@@ -1253,7 +1182,7 @@ impl UnlinkedProjects {
        if settings.unlinked_projects.is_empty() {
            return Self::default();
        }
-        Self::from_model(&load_linked(root, settings), settings)
+        Self::from_model(&load(root), settings)
    }

    pub fn from_model(model: &MavenModel, settings: &ide_core::settings::MavenSettings) -> Self {
@@ -1493,296 +1422,10 @@ pub fn parse_dependency_tree(output: &str) -> Vec<(String, Vec<MavenDependency>)
    out
 }

-// ---------------------------------------------------------------- goto declaration
-
-/// What a go-to-declaration in a POM found, and where.
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub struct PomGoto {
-    /// Absolute path of the file with the declaration: the POM itself, or a parent
-    /// POM of the local repository when the definition is inherited from one.
-    pub path: PathBuf,
-    pub range: Range,
-    /// What was found.
-    pub kind: PomGotoKind,
-    /// The declaration as named for the user (`example.version`, `com.example:example-lib`).
-    pub label: String,
-}
-
-/// The kind of declaration a POM go-to-declaration found.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub enum PomGotoKind {
-    /// A `<properties>` entry of the POM or one of its parents.
-    Property,
-    /// A `<dependencyManagement>` entry providing the dependency's version.
-    ManagedDependency,
-    /// A `<pluginManagement>` entry providing the plugin's version.
-    ManagedPlugin,
-}
-
-/// Byte offset of `pos` (0-based line / UTF-16 column), clamped to `text`.
-fn offset_at(text: &str, pos: Pos) -> usize {
-    let (mut line_seen, mut at) = (0usize, 0usize);
-    if pos.line > 0 {
-        for (i, b) in text.bytes().enumerate() {
-            if b == b'\n' {
-                line_seen += 1;
-                if line_seen == pos.line as usize {
-                    at = i + 1;
-                    break;
-                }
-            }
-        }
-        if line_seen < pos.line as usize {
-            return text.len();
-        }
-    }
-    let line_end = text[at..].find('\n').map_or(text.len(), |i| at + i);
-    let (mut col, mut byte) = (0u32, at);
-    for c in text[at..line_end].chars() {
-        let width = c.len_utf16() as u32;
-        if col + width > pos.col {
-            break;
-        }
-        col += width;
-        byte += c.len_utf8();
-    }
-    byte
-}
-
-/// 0-based line / UTF-16 column of byte offset `at`.
-fn pos_at(text: &str, at: usize) -> Pos {
-    let before = &text[..at];
-    let line_start = before.rfind('\n').map_or(0, |i| i + 1);
-    Pos::new(before.matches('\n').count() as u32, before[line_start..].encode_utf16().count() as u32)
-}
-
-/// The `${property}` reference covering byte offset `at`: its name and the span of
-/// the whole reference. `None` when `at` is outside one (a closing `${…}` before it
-/// ends the search: references do not nest).
-fn property_ref_at(text: &str, at: usize) -> Option<(&str, usize, usize)> {
-    // `at` may sit on the `$` itself.
-    let open = text[..at].rfind("${").or_else(|| text[at..].starts_with("${").then_some(at))?;
-    let close = open + 2 + text[open + 2..].find('}')?;
-    (close >= at).then(|| (text[open + 2..close].trim(), open, close + 1))
-}
-
-/// The elements containing `at`, from the root down to the innermost one.
-fn element_path(root: &Element, at: usize) -> Vec<&Element> {
-    let mut path = vec![root];
-    loop {
-        let Some(next) = path.last().unwrap().children.iter().find(|c| c.start <= at && at < c.end) else {
-            return path;
-        };
-        path.push(next);
-    }
-}
-
-/// The `<groupId>` / `<artifactId>` of a dependency or plugin element, with the
-/// plugin default (`org.apache.maven.plugins`) applied.
-fn coordinates(e: &Element, props: &HashMap<String, String>) -> Option<(String, String)> {
-    let group = if e.name == "plugin" && e.text_of("groupId").is_none() {
-        "org.apache.maven.plugins".to_owned()
-    } else {
-        interpolate(&e.text_of("groupId")?, props)
-    };
-    Some((group, interpolate(&e.text_of("artifactId")?, props)))
-}
-
-/// The go-to-declaration target at `pos` (0-based line / UTF-16 column) of the POM
-/// `text` stored at `path` (the current buffer text when the file is open): a
-/// `${property}` reference to the `<properties>` entry that defines it along the
-/// parent chain, or a dependency / plugin to the `<dependencyManagement>` /
-/// `<pluginManagement>` entry that provides its version (a parent POM, followed into
-/// the local repository when it is not in the project). `None` when there is no
-/// resolvable declaration here.
-pub fn goto_declaration(text: &str, path: &Path, pos: Pos, local_repo: Option<PathBuf>) -> Option<PomGoto> {
-    let root = xml::parse(text).filter(|e| e.name == "project")?;
-    let at = offset_at(text, pos);
-    if let Some((name, _, _)) = property_ref_at(text, at)
-        && !name.is_empty()
-    {
-        return property_target(text, path, name, local_repo);
-    }
-    // A `<dependency>` / `<plugin>` in a declaration position: its version may come
-    // from a management entry of this POM or an ancestor's.
-    let elements = element_path(&root, at);
-    let e = elements.iter().rev().find(|e| e.name == "dependency" || e.name == "plugin")?;
-    if elements.iter().any(|a| a.name == "dependencyManagement" || a.name == "pluginManagement") {
-        return None; // Management entries are declarations; there is nothing to go to.
-    }
-    let kind = match e.name.as_str() {
-        "dependency" => PomGotoKind::ManagedDependency,
-        _ => PomGotoKind::ManagedPlugin,
-    };
-    managed_target(text, path, e, kind, local_repo)
-}
-
-/// The parent POMs of the POM in `text` at `path`, child-first (its `<parent>` refs,
-/// via `relativePath` in the project or the local repository), with their texts.
-fn parent_chain(path: &Path, text: &str, local_repo: Option<PathBuf>) -> Vec<(PathBuf, String)> {
-    let mut resolver = Resolver::new(local_repo, &[]);
-    let path = dunce::canonicalize(path).unwrap_or_else(|_| path.to_path_buf());
-    let mut chain = vec![(path.clone(), text.to_owned())];
-    let mut dir = path.parent().unwrap_or(Path::new("")).to_path_buf();
-    let mut pom = parse_pom(text);
-    for _ in 0..MAX_PARENT_DEPTH {
-        let Some(parent) = pom.and_then(|p| p.parent) else { return chain };
-        let Some(pp) = resolver.parent_path(&dir, &parent) else { return chain };
-        let pp = dunce::canonicalize(&pp).unwrap_or(pp);
-        let Ok(next) = std::fs::read_to_string(&pp) else { return chain };
-        pom = resolver.pom(&pp);
-        dir = pp.parent().unwrap_or(Path::new("")).to_path_buf();
-        chain.push((pp, next));
-    }
-    chain
-}
-
-/// The properties visible in the POM at `chain[i]`: inherited (its parents' and
-/// ancestors' own entries) plus its own, and the `project.*` built-ins.
-fn properties_at(resolver: &mut Resolver, chain: &[(PathBuf, String)], i: usize) -> HashMap<String, String> {
-    let (p, text) = &chain[i];
-    let Some(pom) = parse_pom(text) else { return HashMap::new() };
-    let dir = p.parent().unwrap_or(Path::new("")).to_path_buf();
-    let ctx = resolver.context(p, 0);
-    resolver.properties_for(&pom, &ctx, &dir)
-}
-
-/// Where the property `name` is declared: the `project.*` built-ins go to their
-/// coordinate elements, the rest to the first `<properties>` entry along the parent
-/// chain declaring it (a child's definition wins over a parent's; an active
-/// profile's counts as the POM's own). The winner's path, element range and name.
-fn property_target(text: &str, path: &Path, name: &str, local_repo: Option<PathBuf>) -> Option<PomGoto> {
-    let name = name.strip_prefix("pom.").map(|n| format!("project.{n}")).unwrap_or_else(|| name.to_owned());
-    let resolver = Resolver::new(local_repo.clone(), &[]);
-    let chain = parent_chain(path, text, local_repo);
-    // `project.parent.*` (and the legacy `parent.*` spellings) are declared by the
-    // clicked POM's own `<parent>` section.
-    let parent_key = match name.as_str() {
-        "project.parent.groupId"
-        | "project.parent.artifactId"
-        | "project.parent.version"
-        | "parent.groupId"
-        | "parent.version" => {
-            let key = name.rsplit('.').next().unwrap();
-            Some(&name[name.len() - key.len()..])
-        }
-        _ => None,
-    };
-    if let Some(key) = parent_key {
-        if !matches!(key, "groupId" | "artifactId" | "version") {
-            return None; // No other `project.parent.*` property has a declaration.
-        }
-        let root = xml::parse(&chain[0].1).filter(|e| e.name == "project")?;
-        let e = root.child("parent")?.child(key)?;
-        return Some(PomGoto {
-            path: chain[0].0.clone(),
-            range: range_of(&chain[0].1, e),
-            kind: PomGotoKind::Property,
-            label: name.clone(),
-        });
-    }
-    // Built-in coordinates: the POM's own element, else the first ancestor declaring one.
-    if let Some(key) = name.strip_prefix("project.") {
-        if !matches!(key, "groupId" | "artifactId" | "version" | "packaging" | "name") {
-            return None; // `project.basedir`, `project.build.directory`… have no element.
-        }
-        for (p, text) in &chain {
-            let Some(root) = xml::parse(text).filter(|e| e.name == "project") else { continue };
-            let Some(e) = root.child(key).filter(|e| !e.text.trim().is_empty()) else { continue };
-            return Some(PomGoto {
-                path: p.clone(),
-                range: range_of(text, e),
-                kind: PomGotoKind::Property,
-                label: name.clone(),
-            });
-        }
-        return None;
-    }
-    // A property of `<properties>`: the first POM of the chain (child-first) that
-    // declares it, at project level or in an active profile.
-    for (p, text) in &chain {
-        let Some(root) = xml::parse(text).filter(|e| e.name == "project") else { continue };
-        let active: Vec<String> = parse_pom(text)
-            .map(|pom| resolver.active(&pom.profiles).map(|pr| pr.id.clone()).collect())
-            .unwrap_or_default();
-        // Project level first, then the first active profile declaring the property.
-        let e = root.child("properties").and_then(|props| props.child(&name)).or_else(|| {
-            root.list("profiles", "profile")
-                .into_iter()
-                .find(|profile| {
-                    active.contains(&profile.child("id").map(|id| id.text.trim().to_owned()).unwrap_or_default())
-                        && profile.child("properties").and_then(|props| props.child(&name)).is_some()
-                })?
-                .child("properties")?
-                .child(&name)
-        });
-        if let Some(e) = e {
-            return Some(PomGoto {
-                path: p.clone(),
-                range: range_of(text, e),
-                kind: PomGotoKind::Property,
-                label: name.clone(),
-            });
-        }
-    }
-    None
-}
-
-/// The `<dependencyManagement>` / `<pluginManagement>` entry providing the version
-/// of the dependency / plugin element `e`: this POM's own management first, then the
-/// parent chain, child-first (the nearest declaration wins). Coordinates are matched
-/// after interpolation with each POM's effective properties.
-fn managed_target(
-    text: &str,
-    path: &Path,
-    e: &Element,
-    kind: PomGotoKind,
-    local_repo: Option<PathBuf>,
-) -> Option<PomGoto> {
-    let mut resolver = Resolver::new(local_repo.clone(), &[]);
-    let chain = parent_chain(path, text, local_repo);
-    let key = coordinates(e, &properties_at(&mut resolver, &chain, 0))?;
-    let (section, item) = match kind {
-        PomGotoKind::ManagedDependency => ("dependencyManagement/dependencies", "dependency"),
-        _ => ("build/pluginManagement/plugins", "plugin"),
-    };
-    for (i, (p, text)) in chain.iter().enumerate() {
-        let root = xml::parse(text).filter(|e| e.name == "project")?;
-        let props = properties_at(&mut resolver, &chain, i);
-        let Some(hit) = root.list(section, item).into_iter().find(|m| coordinates(m, &props).as_ref() == Some(&key))
-        else {
-            continue;
-        };
-        let target = hit.child("artifactId").unwrap_or(hit);
-        return Some(PomGoto {
-            path: p.clone(),
-            range: range_of(text, target),
-            kind,
-            label: format!("{}:{}", key.0, key.1),
-        });
-    }
-    None
-}
-
-/// The range of element `e` in `text`.
-fn range_of(text: &str, e: &Element) -> Range {
-    Range::new(pos_at(text, e.start), pos_at(text, e.end))
-}
-
 #[cfg(test)]
 mod tests {
    use super::*;

-    /// `parent_chain` returns paths normalized by `dunce::canonicalize`, so the
-    /// expected values compared against them must go through the same call: the
-    /// temp dirs sit behind symlinks on macOS (`/var` → `/private/var`) and under
-    /// an 8.3 short name on Windows, and raw paths would not match on those runners.
-    fn canon(path: &Path) -> PathBuf {
-        dunce::canonicalize(path).unwrap_or_else(|_| path.to_path_buf())
-    }
-
    /// A plugin jar in `repo` whose descriptor declares `goals`.
    fn write_plugin_jar(repo: &Path, group: &str, artifact: &str, version: &str, goals: &[&str]) {
        let dir = repo.join(group.replace('.', "/")).join(artifact).join(version);
@@ -1818,37 +1461,6 @@ mod tests {
        assert_eq!(p.prefix, "checkstyle");
    }

-    #[test]
-    fn settings_profiles_are_listed_with_the_active_ones_checked() {
-        let tmp = tempfile::tempdir().unwrap();
-        let file = tmp.path().join("settings.xml");
-        std::fs::write(
-            &file,
-            r#"<settings>
-  <profiles>
-    <profile><id>nexus</id></profile>
-    <profile><id>jdk21</id><activation><activeByDefault>true</activeByDefault></activation></profile>
-    <profile><id>release</id></profile>
-    <profile><id>nexus</id></profile>
-    <profile><activation/></profile>
-  </profiles>
-  <activeProfiles><activeProfile>nexus</activeProfile></activeProfiles>
-</settings>"#,
-        )
-        .unwrap();
-        let p = |id: &str, active| MavenProfile { id: id.into(), active_by_default: active };
-        assert_eq!(settings_profiles(&file), [p("nexus", true), p("jdk21", true), p("release", false)]);
-        assert!(settings_profiles(&tmp.path().join("missing.xml")).is_empty());
-
-        let mut s = ide_core::settings::MavenSettings::default();
-        let home = dirs::home_dir().unwrap();
-        assert_eq!(user_settings_file(tmp.path(), &s), Some(home.join(".m2/settings.xml")));
-        s.user_settings = "conf/settings.xml".into();
-        assert_eq!(user_settings_file(tmp.path(), &s), Some(tmp.path().join("conf/settings.xml")));
-        s.user_settings = "~/work/settings.xml".into();
-        assert_eq!(user_settings_file(tmp.path(), &s), Some(home.join("work/settings.xml")));
-    }
-
    #[test]
    fn a_settings_file_names_the_repository_to_read_goals_from() {
        let tmp = tempfile::tempdir().unwrap();
@@ -2087,95 +1699,6 @@ mod tests {
        assert!(model.projects.iter().all(|p| p.command == if cfg!(windows) { "mvn.cmd" } else { "mvn" }));
    }

-    /// Add Maven Projects: a POM inside the project that no reactor lists becomes an
-    /// independent top-level project; one the root reactor lists stays its module.
-    #[test]
-    fn linked_poms_outside_the_reactor_are_top_level_projects() {
-        let tmp = tempfile::tempdir().unwrap();
-        let root = tmp.path();
-        write(
-            root,
-            "pom.xml",
-            "<project><groupId>demo</groupId><artifactId>main</artifactId><version>1.0</version><packaging>pom</packaging><modules><module>core</module></modules></project>",
-        );
-        write(
-            root,
-            "core/pom.xml",
-            "<project><groupId>demo</groupId><artifactId>core</artifactId><version>1.0</version></project>",
-        );
-        write(
-            root,
-            "stub/pom.xml",
-            "<project><groupId>demo</groupId><artifactId>stub</artifactId><version>1.0</version></project>",
-        );
-        let top = |m: &MavenModel| m.projects.iter().map(|p| (p.dir.clone(), p.aggregated)).collect::<Vec<_>>();
-
-        assert_eq!(top(&load_with_linked(root, None, &[], &[])), [("".into(), false), ("core".into(), true)]);
-        let linked: Vec<String> =
-            ["stub/pom.xml", "./core/pom.xml", "../outside/pom.xml", "missing/pom.xml"].map(String::from).into();
-        assert_eq!(
-            top(&load_with_linked(root, None, &[], &linked)),
-            [("".into(), false), ("core".into(), true), ("stub".into(), false)]
-        );
-
-        // Deeper than the folder search reaches: only the link makes it a Maven project.
-        let deep = tempfile::tempdir().unwrap();
-        write(deep.path(), "a/b/c/tool/pom.xml", "<project><artifactId>tool</artifactId></project>");
-        let settings = ide_core::settings::MavenSettings {
-            linked_projects: vec!["a/b/c/tool/pom.xml".into()],
-            ..Default::default()
-        };
-        assert!(!has_projects(deep.path(), &Default::default()));
-        assert!(has_projects(deep.path(), &settings));
-        assert_eq!(top(&load_linked(deep.path(), &settings)), [("a/b/c/tool".into(), false)]);
-    }
-
-    #[test]
-    fn chosen_profiles_bring_their_modules_and_dependencies() {
-        let tmp = tempfile::tempdir().unwrap();
-        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();
@@ -2462,325 +1985,6 @@ mod tests {
            assert_eq!((d.group_id.as_str(), d.version.as_deref()), ("g", Some("1")), "{line}");
        }
    }
-
-    // ---------------------------------------------------- goto declaration
-
-    /// The position of the first character of `needle` (a click on it).
-    fn at(text: &str, needle: &str) -> Pos {
-        pos_at(text, text.find(needle).unwrap())
-    }
-
-    /// A parent POM and a child of it in `tmp`: the parent at `tmp/pom.xml`, the
-    /// child at `tmp/app/pom.xml` (found through the default `../pom.xml`).
-    fn write_parent_child(tmp: &Path, parent: &str, child: &str) {
-        std::fs::create_dir_all(tmp.join("app")).unwrap();
-        std::fs::write(tmp.join("pom.xml"), parent).unwrap();
-        std::fs::write(tmp.join("app/pom.xml"), child).unwrap();
-    }
-
-    const CHILD_HEADER: &str = r#"<project xmlns="http://maven.apache.org/POM/4.0.0">
-  <parent>
-    <groupId>com.example</groupId>
-    <artifactId>parent</artifactId>
-    <version>1.0</version>
-  </parent>
-  <artifactId>app</artifactId>
-"#;
-
-    const PARENT_HEADER: &str = r#"<project xmlns="http://maven.apache.org/POM/4.0.0">
-  <groupId>com.example</groupId>
-  <artifactId>parent</artifactId>
-  <version>1.0</version>
-"#;
-
-    #[test]
-    fn a_property_reference_finds_its_definition_in_the_same_pom() {
-        let text = format!(
-            r#"{CHILD_HEADER}<properties>
-    <example.version>1.2.3</example.version>
-  </properties>
-  <dependencies>
-    <dependency>
-      <groupId>com.example</groupId>
-      <artifactId>lib</artifactId>
-      <version>${{example.version}}</version>
-    </dependency>
-  </dependencies>
-</project>"#
-        );
-        let path = Path::new("/tmp/pom.xml");
-        let goto = goto_declaration(&text, path, at(&text, "${example.version}"), None).unwrap();
-        assert_eq!(goto.kind, PomGotoKind::Property);
-        assert_eq!(goto.label, "example.version");
-        assert_eq!(goto.path, path);
-        let from = text.find("<example.version>").unwrap();
-        let to = text.find("</example.version>").unwrap() + "</example.version>".len();
-        assert_eq!(goto.range, Range::new(pos_at(&text, from), pos_at(&text, to)));
-    }
-
-    #[test]
-    fn an_inherited_property_reference_finds_its_definition_in_the_parent_pom() {
-        let tmp = tempfile::tempdir().unwrap();
-        let parent = format!(
-            r#"{PARENT_HEADER}<properties>
-    <example.version>1.2.3</example.version>
-  </properties>
-</project>"#
-        );
-        let child = format!(
-            r#"{CHILD_HEADER}<dependencies>
-  <dependency>
-    <groupId>com.example</groupId>
-    <artifactId>lib</artifactId>
-    <version>${{example.version}}</version>
-  </dependency>
-</dependencies>
-</project>"#
-        );
-        write_parent_child(tmp.path(), &parent, &child);
-        let path = tmp.path().join("app/pom.xml");
-        let text = std::fs::read_to_string(&path).unwrap();
-        let goto = goto_declaration(&text, &path, at(&text, "${example.version}"), None).unwrap();
-        assert_eq!(goto.kind, PomGotoKind::Property);
-        assert_eq!(goto.path, canon(&tmp.path().join("pom.xml")));
-        let from = parent.find("<example.version>").unwrap();
-        assert_eq!(goto.range.start, pos_at(&parent, from));
-    }
-
-    #[test]
-    fn a_child_property_wins_over_the_parent_s_definition() {
-        let tmp = tempfile::tempdir().unwrap();
-        let parent = format!(
-            r#"{PARENT_HEADER}<properties>
-    <example.version>1.0.0</example.version>
-  </properties>
-</project>"#
-        );
-        let child = format!(
-            r#"{CHILD_HEADER}<properties>
-    <example.version>2.0.0</example.version>
-  </properties>
-  <dependencies>
-    <dependency>
-      <groupId>com.example</groupId>
-      <artifactId>lib</artifactId>
-      <version>${{example.version}}</version>
-    </dependency>
-  </dependencies>
-</project>"#
-        );
-        write_parent_child(tmp.path(), &parent, &child);
-        let path = tmp.path().join("app/pom.xml");
-        let text = std::fs::read_to_string(&path).unwrap();
-        let goto = goto_declaration(&text, &path, at(&text, "${example.version}"), None).unwrap();
-        assert_eq!(goto.path, canon(&path), "the child's own definition");
-        let from = text.find("<example.version>").unwrap();
-        let to = text.find("</example.version>").unwrap() + "</example.version>".len();
-        assert_eq!(goto.range, Range::new(pos_at(&text, from), pos_at(&text, to)));
-        assert!(text[from..to].contains("2.0.0"));
-    }
-
-    #[test]
-    fn a_managed_dependency_reference_finds_the_managing_declaration_in_the_parent() {
-        let tmp = tempfile::tempdir().unwrap();
-        let parent = format!(
-            r#"{PARENT_HEADER}<properties>
-    <example.version>1.2.3</example.version>
-  </properties>
-  <dependencyManagement>
-    <dependencies>
-      <dependency>
-        <groupId>com.example</groupId>
-        <artifactId>example-lib</artifactId>
-        <version>${{example.version}}</version>
-      </dependency>
-    </dependencies>
-  </dependencyManagement>
-</project>"#
-        );
-        let child = format!(
-            r#"{CHILD_HEADER}<dependencies>
-  <dependency>
-    <groupId>com.example</groupId>
-    <artifactId>example-lib</artifactId>
-  </dependency>
-</dependencies>
-</project>"#
-        );
-        write_parent_child(tmp.path(), &parent, &child);
-        let path = tmp.path().join("app/pom.xml");
-        let text = std::fs::read_to_string(&path).unwrap();
-        let goto = goto_declaration(&text, &path, at(&text, "<artifactId>example-lib"), None).unwrap();
-        assert_eq!(goto.kind, PomGotoKind::ManagedDependency);
-        assert_eq!(goto.label, "com.example:example-lib");
-        assert_eq!(goto.path, canon(&tmp.path().join("pom.xml")));
-        let from = parent.find("<artifactId>example-lib</artifactId>").unwrap();
-        let to = from + "<artifactId>example-lib</artifactId>".len();
-        assert_eq!(goto.range, Range::new(pos_at(&parent, from), pos_at(&parent, to)));
-    }
-
-    #[test]
-    fn a_managed_plugin_reference_finds_the_managing_declaration_in_the_parent() {
-        let tmp = tempfile::tempdir().unwrap();
-        let parent = format!(
-            r#"{PARENT_HEADER}<build>
-  <pluginManagement>
-    <plugins>
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-compiler-plugin</artifactId>
-        <version>3.13.0</version>
-      </plugin>
-    </plugins>
-  </pluginManagement>
-</build>
-</project>"#
-        );
-        let child = format!(
-            r#"{CHILD_HEADER}<build>
-  <plugins>
-    <plugin>
-      <artifactId>maven-compiler-plugin</artifactId>
-    </plugin>
-  </plugins>
-</build>
-</project>"#
-        );
-        write_parent_child(tmp.path(), &parent, &child);
-        let path = tmp.path().join("app/pom.xml");
-        let text = std::fs::read_to_string(&path).unwrap();
-        let goto = goto_declaration(&text, &path, at(&text, "<artifactId>maven-compiler-plugin"), None).unwrap();
-        assert_eq!(goto.kind, PomGotoKind::ManagedPlugin);
-        assert_eq!(goto.label, "org.apache.maven.plugins:maven-compiler-plugin");
-        assert_eq!(goto.path, canon(&tmp.path().join("pom.xml")));
-    }
-
-    #[test]
-    fn an_inherited_property_is_found_in_a_parent_pom_of_the_local_repository() {
-        let tmp = tempfile::tempdir().unwrap();
-        let repo = tmp.path().join("repository");
-        let parent_dir = repo.join("com/example/parent/1.0");
-        std::fs::create_dir_all(&parent_dir).unwrap();
-        let parent = format!(
-            r#"{PARENT_HEADER}<properties>
-    <example.version>1.2.3</example.version>
-  </properties>
-</project>"#
-        );
-        std::fs::write(parent_dir.join("parent-1.0.pom"), &parent).unwrap();
-        let child = format!(
-            r#"{CHILD_HEADER}<dependencies>
-  <dependency>
-    <groupId>com.example</groupId>
-    <artifactId>lib</artifactId>
-    <version>${{example.version}}</version>
-  </dependency>
-</dependencies>
-</project>"#
-        );
-        let path = tmp.path().join("app/pom.xml");
-        std::fs::create_dir_all(tmp.path().join("app")).unwrap();
-        std::fs::write(&path, &child).unwrap();
-        let text = std::fs::read_to_string(&path).unwrap();
-        let goto = goto_declaration(&text, &path, at(&text, "${example.version}"), Some(repo)).unwrap();
-        assert_eq!(goto.kind, PomGotoKind::Property);
-        assert_eq!(goto.path, canon(&parent_dir.join("parent-1.0.pom")));
-        assert_eq!(goto.range.start, pos_at(&parent, parent.find("<example.version>").unwrap()));
-    }
-
-    #[test]
-    fn project_version_resolves_to_the_first_pom_declaring_its_own_version() {
-        let tmp = tempfile::tempdir().unwrap();
-        let parent = format!(r#"{PARENT_HEADER}<packaging>pom</packaging></project>"#);
-        let child = format!(
-            r#"{CHILD_HEADER}<dependencies>
-  <dependency>
-    <groupId>com.example</groupId>
-    <artifactId>lib</artifactId>
-    <version>${{project.version}}</version>
-  </dependency>
-</dependencies>
-</project>"#
-        );
-        write_parent_child(tmp.path(), &parent, &child);
-        let path = tmp.path().join("app/pom.xml");
-        let text = std::fs::read_to_string(&path).unwrap();
-        let goto = goto_declaration(&text, &path, at(&text, "${project.version}"), None).unwrap();
-        assert_eq!(goto.path, canon(&tmp.path().join("pom.xml")), "the child has no own <version>");
-        assert_eq!(goto.range.start, pos_at(&parent, parent.find("<version>").unwrap()));
-    }
-
-    #[test]
-    fn clicks_without_a_resolvable_declaration_find_nothing() {
-        let tmp = tempfile::tempdir().unwrap();
-        let parent = format!(
-            r#"{PARENT_HEADER}<dependencyManagement>
-  <dependencies>
-    <dependency>
-      <groupId>com.example</groupId>
-      <artifactId>managed-lib</artifactId>
-      <version>1.0</version>
-    </dependency>
-  </dependencies>
-</dependencyManagement>
-</project>"#
-        );
-        let child = format!(
-            r#"{CHILD_HEADER}<dependencies>
-  <dependency>
-    <groupId>com.example</groupId>
-    <artifactId>direct-lib</artifactId>
-    <version>${{missing.key}}</version>
-  </dependency>
-  <dependency>
-    <groupId>com.example</groupId>
-    <artifactId>other-lib</artifactId>
-    <version>2.0</version>
-  </dependency>
-</dependencies>
-</project>"#
-        );
-        write_parent_child(tmp.path(), &parent, &child);
-        let path = tmp.path().join("app/pom.xml");
-        let text = std::fs::read_to_string(&path).unwrap();
-        // The property is declared nowhere along the chain.
-        assert_eq!(goto_declaration(&text, &path, at(&text, "${missing.key}"), None), None);
-        // The dependency names its own version: it is the declaration.
-        assert_eq!(goto_declaration(&text, &path, at(&text, "<artifactId>other-lib"), None), None);
-        // A management entry is a declaration itself, not a reference.
-        let parent_path = tmp.path().join("pom.xml");
-        let parent_text = std::fs::read_to_string(&parent_path).unwrap();
-        assert_eq!(
-            goto_declaration(&parent_text, &parent_path, at(&parent_text, "<artifactId>managed-lib"), None),
-            None
-        );
-        // Offsets beyond the document, and non-POM documents, find nothing.
-        assert_eq!(goto_declaration(&text, &path, Pos::new(999, 0), None), None);
-        assert_eq!(goto_declaration("<project></project>", &path, Pos::new(0, 3), None), None);
-    }
-
-    #[test]
-    fn a_property_reference_after_non_ascii_text_is_still_found() {
-        let text = format!(
-            r#"{CHILD_HEADER}<properties>
-    <!-- Версия сборки: сборка 2026 -->
-    <example.version>1.2.3</example.version>
-  </properties>
-  <dependencies>
-    <dependency>
-      <groupId>com.example</groupId>
-      <artifactId>lib</artifactId>
-      <!-- Проверка: ссылка на свойство -->
-      <version>${{example.version}}</version>
-    </dependency>
-  </dependencies>
-</project>"#
-        );
-        let path = Path::new("/tmp/pom.xml");
-        let goto = goto_declaration(&text, path, at(&text, "${example.version}"), None).unwrap();
-        assert_eq!(goto.kind, PomGotoKind::Property);
-        assert_eq!(goto.path, path);
-    }
 }

 #[cfg(test)]
@@ -95,24 +95,6 @@ fn maven_sync_goals(effective: &Path, offline: bool) -> Vec<String> {
        "-Dverbose".into(),
    ]
 }
-
-/// The settings' Maven options for the sync runs: the thread count (`-T`, also
-/// `--threads`) is left out, because the sync pins its own `-T1` — its console
-/// output is parsed as one stream, which a parallel build interleaves.
-fn sync_maven_options(options: &[String]) -> Vec<String> {
-    let mut out = Vec::with_capacity(options.len());
-    let mut args = options.iter();
-    while let Some(arg) = args.next() {
-        if arg == "-T" || arg == "--threads" {
-            args.next(); // the count itself
-        } else if (arg.starts_with("-T") && arg.len() > 2) || arg.starts_with("--threads=") {
-            // `--threads=4` / `-T4`: the count is part of the argument.
-        } else {
-            out.push(arg.clone());
-        }
-    }
-    out
-}
 const GRADLE_CACHE: &str = "gradle.json";
 const MAVEN_PROFILES: &str = "maven-profiles.json";

@@ -301,12 +283,7 @@ pub fn sync_maven(
    cancel: &CancellationToken,
    progress: &dyn Fn(SyncProgress),
 ) -> IdeResult<()> {
-    let mut model = maven::load_with_linked(
-        root,
-        maven::default_local_repo(),
-        &options.profiles,
-        &options.maven_settings.linked_projects,
-    );
+    let mut model = maven::load(root);
    maven::UnlinkedProjects::from_model(&model, &options.maven_settings).filter(&mut model);
    std::fs::create_dir_all(cache_dir)?;
    let mut cache = MavenCache {
@@ -338,11 +315,8 @@ 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);
-        // `-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(sync_maven_options(&options.maven_options));
+        let mut args: Vec<String> = vec!["-B".into(), "-fae".into(), "-Dstyle.color=never".into()];
+        args.extend(options.maven_options.iter().cloned());
        if options.offline {
            args.push("-o".into());
        }
@@ -396,25 +370,8 @@ 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"))?;
-    sync_gradle_model(root, cache_dir, &model, options, cancel, progress)
-}
-
-/// Syncs this exact linked build; another build's task paths and cache cannot interfere.
-pub fn sync_gradle_model(
-    root: &Path,
-    cache_dir: &Path,
-    model: &GradleModel,
-    options: &SyncOptions,
-    cancel: &CancellationToken,
-    progress: &dyn Fn(SyncProgress),
-) -> IdeResult<()> {
-    if cancel.is_cancelled() {
-        return Err(IdeError::cancelled());
-    }
-    let mut model = model.clone();
-    let cache_dir = gradle::cache_dir(cache_dir, &model.dir);
-    std::fs::create_dir_all(&cache_dir)?;
+    let 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![
@@ -429,24 +386,14 @@ pub fn sync_gradle_model(
        args.push("--offline".into());
    }
    progress(SyncProgress { message: "Loading Gradle tasks".into(), fraction: None });
-    let out = match run(
+    let out = run(
        options.gradle_command.as_deref().unwrap_or(&model.command),
        &args,
        &root.join(&model.dir),
        &options.env,
        cancel,
        |_| {},
-    ) {
-        Ok(out) => out,
-        Err(_) if cancel.is_cancelled() => return Err(IdeError::cancelled()),
-        Err(error) if error.kind == ide_core::error::ErrorKind::Unavailable => {
-            Output { success: false, text: error.message }
-        }
-        Err(error) => return Err(error),
-    };
-    if cancel.is_cancelled() {
-        return Err(IdeError::cancelled());
-    }
+    )?;
    let projects = if out.success { parse_reported_projects(&out.text) } else { Vec::new() };
    // Hash the build files of the reported projects, or the model is stale right after the sync.
    gradle::merge_reported_projects(root, &mut model, &projects);
@@ -457,128 +404,13 @@ pub fn sync_gradle_model(
        tasks: if out.success { gradle::parse_tasks(&out.text) } else { Vec::new() },
        projects,
    };
-    write_cache(&cache_dir, GRADLE_CACHE, &cache)
+    write_cache(cache_dir, GRADLE_CACHE, &cache)
 }

 #[cfg(test)]
 mod tests {
    use super::*;

-    #[cfg(unix)]
-    #[test]
-    fn unavailable_gradle_launchers_are_cached_without_stopping_other_builds() {
-        use std::os::unix::fs::PermissionsExt;
-        let temp = tempfile::tempdir().unwrap();
-        let root = temp.path();
-        for dir in ["a", "b"] {
-            std::fs::create_dir(root.join(dir)).unwrap();
-            std::fs::write(root.join(dir).join("build.gradle"), "").unwrap();
-        }
-        let wrapper = root.join("b/gradlew");
-        std::fs::write(&wrapper, "#!/bin/sh\nprintf '%s\\n' 'Build tasks' '-----------' 'healthy - ok'\n").unwrap();
-        std::fs::set_permissions(&wrapper, std::fs::Permissions::from_mode(0o755)).unwrap();
-        let settings = ide_core::settings::GradleSettings {
-            linked_projects: Some(vec!["a".into(), "b".into()]),
-            ..Default::default()
-        };
-        let mut models = gradle::load_linked(root, &settings);
-        models[0].command = root.join("a/missing-gradlew").to_string_lossy().into_owned();
-        let cache = root.join("cache");
-        let run = |model: &GradleModel| {
-            sync_gradle_model(root, &cache, model, &SyncOptions::default(), &CancellationToken::new(), &|_| {})
-        };
-        for model in &models {
-            run(model).unwrap();
-        }
-        let loaded = crate::load_linked(root, &cache, None, &Default::default(), &settings);
-        assert!(loaded.gradle[0].sync_error.as_deref().unwrap().contains("cannot start"));
-        assert!(loaded.gradle[1].sync_error.is_none());
-        assert_eq!(loaded.gradle[1].projects[0].tasks[0].name, "healthy");
-        let bad_wrapper = root.join("a/gradlew");
-        std::fs::write(&bad_wrapper, "#!/bin/sh\nexit 0\n").unwrap();
-        std::fs::set_permissions(&bad_wrapper, std::fs::Permissions::from_mode(0o644)).unwrap();
-        models[0].command = bad_wrapper.to_string_lossy().into_owned();
-        run(&models[0]).unwrap();
-        let loaded = crate::load_linked(root, &cache, None, &Default::default(), &settings);
-        assert!(loaded.gradle[0].sync_error.as_deref().unwrap().contains("cannot start"));
-        assert!(loaded.gradle[1].sync_error.is_none());
-        let blocked_cache = root.join("blocked-cache");
-        std::fs::write(&blocked_cache, "a file cannot contain sync caches").unwrap();
-        assert!(
-            sync_gradle_model(
-                root,
-                &blocked_cache,
-                &models[0],
-                &SyncOptions::default(),
-                &CancellationToken::new(),
-                &|_| {}
-            )
-            .is_err()
-        );
-    }
-
-    #[cfg(unix)]
-    #[test]
-    fn independent_syncs_do_not_share_tasks_launchers_environments_or_failures() {
-        use std::os::unix::fs::PermissionsExt;
-        let temp = tempfile::tempdir().unwrap();
-        let root = temp.path();
-        for dir in ["a", "b"] {
-            let build = root.join(dir);
-            std::fs::create_dir_all(build.join("app")).unwrap();
-            std::fs::write(build.join("settings.gradle"), "include 'app'").unwrap();
-            std::fs::write(build.join("app/build.gradle"), "").unwrap();
-            let report = serde_json::json!({"path": ":app", "dir": build.join("app")});
-            let launcher = build.join("gradlew");
-            std::fs::write(
-                &launcher,
-                format!("#!/bin/sh\npwd > actual-cwd\nprintf '%s' \"$JAVA_HOME\" > actual-env\nprintf '%s\\n' '@openidea-model\t{report}' 'Build tasks' '-----------' 'app:custom{dir} - custom task'\n"),
-            ).unwrap();
-            std::fs::set_permissions(launcher, std::fs::Permissions::from_mode(0o755)).unwrap();
-        }
-        let settings = ide_core::settings::GradleSettings {
-            linked_projects: Some(vec!["a".into(), "b".into()]),
-            ..Default::default()
-        };
-        let cache = root.join("cache");
-        let models = gradle::load_linked(root, &settings);
-        for model in &models {
-            let options = SyncOptions {
-                env: BTreeMap::from([("JAVA_HOME".into(), format!("/jdk-{}", model.dir))]),
-                ..Default::default()
-            };
-            sync_gradle_model(root, &cache, model, &options, &CancellationToken::new(), &|_| {}).unwrap();
-            assert_eq!(
-                std::fs::read_to_string(root.join(&model.dir).join("actual-env")).unwrap(),
-                format!("/jdk-{}", model.dir)
-            );
-            assert_eq!(
-                std::fs::read_to_string(root.join(&model.dir).join("actual-cwd")).unwrap().trim(),
-                root.join(&model.dir).canonicalize().unwrap().to_string_lossy()
-            );
-        }
-        let load = || crate::load_linked(root, &cache, None, &Default::default(), &settings);
-        let model = load();
-        assert_eq!(model.gradle[0].projects[0].tasks[0].name, "customa");
-        assert_eq!(model.gradle[1].projects[0].tasks[0].name, "customb");
-        assert_ne!(gradle::cache_dir(&cache, "a"), gradle::cache_dir(&cache, "b"));
-        let before = std::fs::read(gradle::cache_dir(&cache, "a").join(GRADLE_CACHE)).unwrap();
-        std::fs::write(root.join("b/gradlew"), "#!/bin/sh\nprintf 'FAILURE: broken b\\n'\nexit 1\n").unwrap();
-        sync_gradle_model(root, &cache, &models[1], &SyncOptions::default(), &CancellationToken::new(), &|_| {})
-            .unwrap();
-        let model = load();
-        assert!(model.gradle[0].sync_error.is_none());
-        assert!(model.gradle[1].sync_error.is_some());
-        assert_eq!(std::fs::read(gradle::cache_dir(&cache, "a").join(GRADLE_CACHE)).unwrap(), before);
-        let cancel = CancellationToken::new();
-        cancel.cancel();
-        assert!(sync_gradle_model(root, &cache, &models[0], &SyncOptions::default(), &cancel, &|_| {}).is_err());
-        assert_eq!(std::fs::read(gradle::cache_dir(&cache, "a").join(GRADLE_CACHE)).unwrap(), before);
-        let unlinked = ide_core::settings::GradleSettings { linked_projects: Some(vec![]), ..Default::default() };
-        assert!(crate::load_linked(root, &cache, None, &Default::default(), &unlinked).gradle.is_empty());
-        assert!(crate::gradle_source_roots(root, &cache, &unlinked).is_empty());
-    }
-
    #[cfg(unix)]
    #[test]
    fn gradle_sync_uses_resolved_command_and_environment() {
@@ -766,7 +598,7 @@ mod tests {
        write(&projects);
        let first = reported_gradle_projects(&cache_dir);
        assert!(Arc::ptr_eq(&first, &reported_gradle_projects(&cache_dir)), "unchanged: not parsed again");
-        assert_eq!(crate::gradle_external_roots(&root, &cache_dir, &Default::default()), [billing]);
+        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();
@@ -848,38 +680,4 @@ mod tests {
        assert_eq!(error_summary(text), "Failed to execute goal");
        assert_eq!(error_summary("one\nlast line\n\n"), "last line");
    }
-
-    #[test]
-    fn maven_sync_leaves_out_the_settings_thread_count() {
-        // The sync pins its own `-T1`; the user's `-T` (Settings › Maven) would win
-        // over it on the mvnd command line and interleave the parsed output.
-        let options = ["-s".to_owned(), "settings.xml".to_owned(), "-T".to_owned(), "4".to_owned()];
-        assert_eq!(sync_maven_options(&options), ["-s", "settings.xml"]);
-        let options = ["--threads".to_owned(), "2C".to_owned(), "-Dmaven.repo.local=/m2".to_owned()];
-        assert_eq!(sync_maven_options(&options), ["-Dmaven.repo.local=/m2"]);
-        assert_eq!(sync_maven_options(&["-T4".to_owned()]), Vec::<String>::new());
-        assert_eq!(sync_maven_options(&["--threads=4".to_owned()]), Vec::<String>::new());
-        assert!(sync_maven_options(&[]).is_empty());
-    }
-
-    #[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}");
-    }
 }
@@ -26,12 +26,12 @@ pub fn artifacts(root: &Path, model: &BuildModel) -> Vec<WebArtifact> {
            });
        }
    }
-    for gradle in &model.gradle {
+    if let Some(gradle) = &model.gradle {
        for p in &gradle.projects {
            let script = p.build_file.as_ref().and_then(|f| fs::read_to_string(root.join(f)).ok()).unwrap_or_default();
            if p.tasks.iter().any(|t| t.name == "war") || crate::gradle::has_war_plugin(&script) {
                out.push(WebArtifact {
-                    id: gradle_artifact_id(gradle, &p.path),
+                    id: format!("gradle:{}", p.path),
                    name: p.name.clone(),
                    module: p.dir.clone(),
                    tool: "gradle".into(),
@@ -42,14 +42,6 @@ pub fn artifacts(root: &Path, model: &BuildModel) -> Vec<WebArtifact> {
    out
 }

-fn gradle_artifact_id(build: &crate::GradleModel, path: &str) -> String {
-    if build.dir.is_empty() {
-        format!("gradle:{path}")
-    } else {
-        format!("gradle:{}", serde_json::to_string(&(&build.dir, path)).unwrap())
-    }
-}
-
 pub struct WebBuild {
    pub command: String,
    pub args: Vec<String>,
@@ -158,14 +150,9 @@ pub fn build(root: &Path, model: &BuildModel, id: &str, cache: &Path) -> IdeResu
            maven_project: Some((probe, output)),
        });
    }
-    if let Some(legacy_path) = id.strip_prefix("gradle:") {
-        let identity = serde_json::from_str::<(String, String)>(legacy_path).ok();
-        let (g, path) = match &identity {
-            Some((dir, path)) => (model.gradle.iter().find(|g| g.dir == *dir), path.as_str()),
-            None => (model.gradle.first(), legacy_path),
-        };
-        let g = g.ok_or_else(|| IdeError::invalid("Choose a Gradle WAR module"))?;
-        if !artifacts(root, model).iter().any(|a| a.id == gradle_artifact_id(g, path)) {
+    if let Some(path) = id.strip_prefix("gradle:") {
+        let g = model.gradle.as_ref().ok_or_else(|| IdeError::invalid("Choose a Gradle WAR module"))?;
+        if !artifacts(root, model).iter().any(|a| a.id == id) {
            return Err(IdeError::invalid("Choose a Gradle WAR module"));
        }
        let script = cache.join("war.init.gradle");
@@ -199,28 +186,6 @@ pub fn build(root: &Path, model: &BuildModel, id: &str, cache: &Path) -> IdeResu

 #[cfg(test)]
 mod tests {
-    #[test]
-    fn independent_war_modules_have_distinct_ids_and_build_in_their_own_directory() {
-        let temp = tempfile::tempdir().unwrap();
-        let root = temp.path();
-        for dir in ["a", "b"] {
-            std::fs::create_dir(root.join(dir)).unwrap();
-            std::fs::write(root.join(dir).join("build.gradle"), "plugins { id 'war' }").unwrap();
-        }
-        let settings = ide_core::settings::GradleSettings {
-            linked_projects: Some(vec!["a".into(), "b".into()]),
-            ..Default::default()
-        };
-        let model = crate::load_linked(root, &root.join("cache"), None, &Default::default(), &settings);
-        let artifacts = super::artifacts(root, &model);
-        assert_eq!(artifacts.len(), 2);
-        assert_ne!(artifacts[0].id, artifacts[1].id);
-        for (artifact, dir) in artifacts.iter().zip(["a", "b"]) {
-            let plan = super::build(root, &model, &artifact.id, &root.join(format!("cache/{dir}"))).unwrap();
-            assert_eq!(plan.cwd, dir);
-        }
-        assert_eq!(super::build(root, &model, "gradle::", &root.join("legacy")).unwrap().cwd, "a");
-    }
    use super::*;
    #[test]
    fn maven_war_modules_use_resolved_artifact_file() {
@@ -1,8 +1,8 @@
 //! The file list on the OS clipboard: what Explorer copies when the user
 //! copies files, so the project view can paste them, and what the project view
 //! writes so Explorer can paste the files it copied (IDEA does both). The
-//! written list comes with the file names as text, so a paste into an editor
-//! inserts them instead of doing nothing (#1878).
+//! written list comes with the paths as text, so a paste into an editor
+//! inserts them instead of doing nothing.
 //!
 //! Windows keeps it as `CF_HDROP`: a `DROPFILES` header and a double-NUL
 //! terminated list of absolute paths, wide when `fWide` is set. The data is set
@@ -44,21 +44,6 @@ pub fn set_files(paths: &[PathBuf]) -> bool {
    imp::set_files(paths)
 }

-/// The text flavor written beside the file list: the files' names, one per
-/// line. An editor paste inserts names, not the absolute paths the file list
-/// keeps for Explorer (#1878; IDEA's text flavor is names too). A path with no
-/// file name (a root like `C:\`) keeps its whole path.
-#[cfg(any(windows, target_os = "macos", test))]
-fn names_text(paths: &[PathBuf], separator: &str) -> String {
-    paths
-        .iter()
-        .map(|p| {
-            p.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_else(|| p.to_string_lossy().into_owned())
-        })
-        .collect::<Vec<_>>()
-        .join(separator)
-}
-
 /// `DROPFILES` for `paths`, in the wide form so names outside the ANSI code
 /// page survive. Empty paths are skipped.
 pub fn encode(paths: &[PathBuf]) -> Vec<u8> {
@@ -123,7 +108,7 @@ pub fn decode(bytes: &[u8]) -> Vec<PathBuf> {

 #[cfg(windows)]
 mod imp {
-    use super::{HEADER, decode, encode, names_text};
+    use super::{HEADER, decode, encode};
    use std::ffi::c_void;
    use std::path::PathBuf;
    use std::ptr;
@@ -235,9 +220,9 @@ mod imp {
        if bytes.len() <= HEADER {
            return false;
        }
-        // The file names as text: the file list keeps the absolute paths for
-        // Explorer, while an editor paste inserts the names (#1878).
-        let text = names_text(paths, "\r\n");
+        // The paths as text, newline-separated, so pasting into an editor
+        // inserts them (IDEA writes the list and the text together).
+        let text = paths.iter().map(|p| p.to_string_lossy().into_owned()).collect::<Vec<_>>().join("\r\n");
        // SAFETY: the blocks are allocated, filled, handed to the clipboard and
        // freed only on the paths where the clipboard did not take ownership.
        unsafe {
@@ -257,7 +242,7 @@ mod imp {
                return false;
            }
            // Replacing the list also drops the text the user copied before;
-            // the file names are set back with it.
+            // the paths' own text is set back with it.
            if EmptyClipboard() == 0 {
                CloseClipboard();
                GlobalFree(memory);
@@ -293,8 +278,6 @@ mod imp {
    use objc2_foundation::{NSArray, NSDictionary, NSNumber, NSString, NSURL};
    use std::path::PathBuf;

-    use super::names_text;
-
    /// `NSURL` as the one class to read, limited to file URLs: a web link the
    /// user copied is not a file to paste.
    fn read_file_urls<R>(
@@ -355,11 +338,13 @@ mod imp {
                urls.iter().map(|url| ProtocolObject::from_ref(&**url)).collect();
            let board = NSPasteboard::generalPasteboard();
            // Replacing the list also drops the text the user copied before;
-            // the file names are set back as text, so an editor paste inserts
-            // names, not paths (#1878).
+            // the paths' own text is set back with it, so an editor paste
+            // inserts them (IDEA writes the list and the text together).
            board.clearContents();
            let written = board.writeObjects(&NSArray::from_slice(&writers));
-            let text = NSString::from_str(&names_text(paths, "\n"));
+            let text = NSString::from_str(
+                &paths.iter().map(|p| p.to_string_lossy().into_owned()).collect::<Vec<_>>().join("\n"),
+            );
            board.setString_forType(&text, unsafe { NSPasteboardTypeString });
            written
        })
@@ -430,15 +415,6 @@ mod tests {
        assert_eq!(decode(&far), Vec::<PathBuf>::new());
    }

-    #[test]
-    fn the_text_flavor_is_the_file_names() {
-        assert_eq!(names_text(&paths(&["C:/work/project/a.txt", "C:/work/project/sub"]), "\r\n"), "a.txt\r\nsub");
-        // A path with no file name (the filesystem root) keeps its whole path.
-        let root = PathBuf::from("/");
-        assert!(root.file_name().is_none());
-        assert_eq!(names_text(std::slice::from_ref(&root), "\n"), root.to_string_lossy());
-    }
-
    #[test]
    fn an_ansi_list_is_still_read_before_the_terminator() {
        let mut bytes = vec![0u8; HEADER];
@@ -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", "Win32_System_Diagnostics_ToolHelp", "Win32_System_Threading"] }
+windows-sys = { version = "0.61", features = ["Win32_Globalization", "Win32_Security", "Win32_System_Registry", "Win32_Foundation"] }
@@ -166,16 +166,6 @@ impl Default for CompletionSettings {
 pub struct AutoImportSettings {
    pub add_unambiguous: bool,
    pub optimize_on_the_fly: bool,
-    pub imports_on_paste: ImportsOnPaste,
-}
-
-#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub enum ImportsOnPaste {
-    #[default]
-    Ask,
-    Always,
-    Never,
 }

 /// Editor › General › Code Folding.
@@ -261,10 +251,7 @@ pub struct SmartKeysSettings {
    pub tab_out_of_pair: bool,
    /// Reformat on paste: `none` | `indentBlock` | `indentEachLine`.
    pub reformat_on_paste: String,
-    pub escape_on_paste: bool,
    pub smart_indent: bool,
-    /// Enter › Insert documentation comment stub: Enter after `/**` closes the comment.
-    pub insert_doc_stub: bool,
    /// Backspace › Unindent: `autoindent` (proper indent position) | `nearest` indent position | `none`.
    pub backspace_unindent: String,
 }
@@ -279,9 +266,7 @@ impl Default for SmartKeysSettings {
            surround_selection: true,
            tab_out_of_pair: true,
            reformat_on_paste: "indentEachLine".into(),
-            escape_on_paste: true,
            smart_indent: true,
-            insert_doc_stub: true,
            backspace_unindent: "autoindent".into(),
        }
    }
@@ -476,24 +461,3 @@ impl Default for EncodingSettings {
        }
    }
 }
-
-#[cfg(test)]
-mod auto_import_tests {
-    use super::{AutoImportSettings, ImportsOnPaste};
-
-    #[test]
-    fn imports_on_paste_defaults_to_ask_for_existing_settings() {
-        let settings: AutoImportSettings = serde_json::from_str(r#"{"addUnambiguous":true}"#).unwrap();
-        assert!(settings.add_unambiguous);
-        assert_eq!(settings.imports_on_paste, ImportsOnPaste::Ask);
-    }
-
-    #[test]
-    fn imports_on_paste_modes_round_trip() {
-        for mode in ["ask", "always", "never"] {
-            let json = serde_json::json!({ "importsOnPaste": mode });
-            let settings: AutoImportSettings = serde_json::from_value(json).unwrap();
-            assert_eq!(serde_json::to_value(settings).unwrap()["importsOnPaste"], mode);
-        }
-    }
-}
@@ -15,8 +15,6 @@ use std::sync::Arc;
 pub enum IdeEvent {
    /// Project window membership or selection changed.
    WindowGroupsChanged,
-    /// A window entered or left full screen, itself or as a member of a full-screen window group.
-    WindowFullscreenChanged,
    ProjectTrustChanged {
        root: crate::IpcPath,
        trusted: bool,
@@ -231,9 +229,6 @@ pub enum DebugEvent {
        thread_id: i64,
        started: bool,
    },
-    /// The program runs in a terminal the IDE gave it (`runInTerminal`): what is typed for it
-    /// in the debug console reaches its input.
-    ProgramInput,
    BreakpointsChanged {
        path: crate::IpcPath,
    },
@@ -1,124 +0,0 @@
-//! Go workspace module paths shared by project builds and run detection.
-use std::path::PathBuf;
-
-/// Module directories from a go.work file. Quoted paths and comments follow Go's file syntax.
-pub fn work_modules(text: &str) -> Vec<PathBuf> {
-    let mut tokens = Vec::new();
-    let mut chars = text.chars().peekable();
-    while let Some(ch) = chars.next() {
-        match ch {
-            '\n' | '(' | ')' => tokens.push(ch.to_string()),
-            ch if ch.is_whitespace() => {}
-            '/' if chars.peek() == Some(&'/') => {
-                for c in chars.by_ref() {
-                    if c == '\n' {
-                        tokens.push("\n".into());
-                        break;
-                    }
-                }
-            }
-            '"' | '`' => {
-                let Some(token) = quoted_work_path(&mut chars, ch) else { return Vec::new() };
-                tokens.push(token);
-            }
-            _ => {
-                let mut token = ch.to_string();
-                while chars.peek().is_some_and(|c| !c.is_whitespace() && *c != '(' && *c != ')') {
-                    token.push(chars.next().unwrap());
-                }
-                tokens.push(token);
-            }
-        }
-    }
-    let mut out = Vec::new();
-    let mut start = true;
-    let mut tokens = tokens.into_iter();
-    while let Some(token) = tokens.next() {
-        if token == "\n" {
-            start = true;
-            continue;
-        }
-        if start
-            && token == "use"
-            && let Some(path) = tokens.next()
-        {
-            if path == "(" {
-                let mut paths = Vec::new();
-                let mut closed = false;
-                for path in tokens.by_ref() {
-                    if path == ")" {
-                        closed = true;
-                        break;
-                    }
-                    if path != "\n" && !path.is_empty() {
-                        paths.push(PathBuf::from(path));
-                    }
-                }
-                if closed {
-                    out.extend(paths);
-                }
-            } else if path != "\n" && !path.is_empty() {
-                out.push(PathBuf::from(path));
-            }
-        }
-        start = false;
-    }
-    let mut seen = std::collections::HashSet::new();
-    out.retain(|path| seen.insert(path.clone()));
-    out
-}
-
-fn quoted_work_path(chars: &mut std::iter::Peekable<std::str::Chars<'_>>, quote: char) -> Option<String> {
-    let mut bytes = Vec::new();
-    while let Some(ch) = chars.next() {
-        if ch == quote {
-            return String::from_utf8(bytes).ok();
-        }
-        if ch == '\\' && quote == '"' {
-            let escaped = chars.next()?;
-            let byte = match escaped {
-                'a' => 7,
-                'b' => 8,
-                'f' => 12,
-                'n' => 10,
-                'r' => 13,
-                't' => 9,
-                'v' => 11,
-                '\\' => b'\\',
-                '"' => b'"',
-                'x' => {
-                    let digits: String = chars.by_ref().take(2).collect();
-                    if digits.len() != 2 {
-                        return None;
-                    }
-                    u8::from_str_radix(&digits, 16).ok()?
-                }
-                'u' | 'U' => {
-                    let width = if escaped == 'u' { 4 } else { 8 };
-                    let digits: String = chars.by_ref().take(width).collect();
-                    if digits.len() != width {
-                        return None;
-                    }
-                    let ch = char::from_u32(u32::from_str_radix(&digits, 16).ok()?)?;
-                    bytes.extend_from_slice(ch.to_string().as_bytes());
-                    continue;
-                }
-                '0'..='7' => {
-                    let digits = format!("{escaped}{}", chars.by_ref().take(2).collect::<String>());
-                    if digits.len() != 3 {
-                        return None;
-                    }
-                    u8::from_str_radix(&digits, 8).ok()?
-                }
-                _ => return None,
-            };
-            bytes.push(byte);
-        } else {
-            if ch == '\n' && quote == '"' {
-                return None;
-            }
-            bytes.extend_from_slice(ch.to_string().as_bytes());
-        }
-    }
-    None
-}
@@ -2,18 +2,6 @@
 //! 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",
@@ -115,15 +103,4 @@ 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")));
-    }
 }
@@ -36,23 +36,6 @@ impl Default for InspectionSettings {
    }
 }

-impl InspectionSettings {
-    /// Overrides of the profile in effect; `Default`'s when `profile` names none that exists.
-    pub fn active(&self) -> &BTreeMap<String, InspectionOverride> {
-        let custom = |level: &str, key: &str| match level {
-            "ide" => self.ide_profiles.get(key),
-            "project" => self.project_profiles.get(key),
-            _ => None,
-        };
-        match self.profile.as_str() {
-            "project" => &self.project,
-            id => {
-                id.split_once(':').and_then(|(level, key)| custom(level, key)).map_or(&self.default, |p| &p.overrides)
-            }
-        }
-    }
-}
-
 /// A named profile made with Copy.
 #[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
 #[serde(default, rename_all = "camelCase")]
@@ -128,20 +111,4 @@ mod tests {
        let back: InspectionSettings = serde_json::from_str(&serde_json::to_string(&s).unwrap()).unwrap();
        assert_eq!(back, s);
    }
-
-    #[test]
-    fn active_profile_falls_back_to_default() {
-        let off = |id: &str| {
-            BTreeMap::from([(id.to_owned(), InspectionOverride { enabled: Some(false), ..Default::default() })])
-        };
-        let mut s = InspectionSettings { default: off("a"), project: off("b"), ..Default::default() };
-        s.ide_profiles.insert("strict".into(), CustomInspectionProfile { name: "Strict".into(), overrides: off("c") });
-        assert!(s.active().contains_key("a"));
-        s.profile = "project".into();
-        assert!(s.active().contains_key("b"));
-        s.profile = "ide:strict".into();
-        assert!(s.active().contains_key("c"));
-        s.profile = "project:gone".into();
-        assert!(s.active().contains_key("a"));
-    }
 }
@@ -7,7 +7,6 @@
 pub mod editor_settings;
 pub mod error;
 pub mod event;
-pub mod go;
 pub mod ids;
 pub mod ignored;
 pub mod inspection_settings;
@@ -17,7 +16,6 @@ pub mod jsonc;
 pub mod output_encoding;
 pub mod process;
 pub mod project_dir;
-pub mod project_roots;
 pub mod proxy_settings;
 pub mod remote_settings;
 pub mod settings;
@@ -26,7 +24,6 @@ pub mod text;
 pub mod tool_path;
 pub mod version_managers;
 pub mod workflow_settings;
-pub mod wsl;

 pub use error::{IdeError, IdeResult};
 pub use event::{EventSink, IdeEvent, NullSink, SharedSink};
@@ -43,21 +43,19 @@ 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, then a
-///   wait for what the child started to be gone.
+/// - Windows: `taskkill /T /F`, which walks the tree from the child's process id.
 pub fn kill_tree(child: &mut Child) {
    #[cfg(unix)]
    signal_group(child, libc::SIGKILL);
    #[cfg(windows)]
-    taskkill_tree_of(child.id());
+    taskkill_tree(child);
    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.
+/// process group (spawn it with [`own_group`]) or `taskkill /T /F`. 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) {
@@ -67,7 +65,15 @@ pub fn kill_tree_of(pid: u32) {
        }
    }
    #[cfg(windows)]
-    taskkill_tree_of(pid);
+    {
+        let mut taskkill = Command::new("taskkill");
+        prepare(&mut taskkill)
+            .args(["/T", "/F", "/PID", &pid.to_string()])
+            .stdin(Stdio::null())
+            .stdout(Stdio::null())
+            .stderr(Stdio::null());
+        let _ = taskkill.status();
+    }
    #[cfg(not(any(unix, windows)))]
    let _ = pid;
 }
@@ -100,107 +106,15 @@ 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)]
-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);
+fn taskkill_tree(child: &Child) {
    let mut taskkill = Command::new("taskkill");
    prepare(&mut taskkill)
-        .args(["/T", "/F", "/PID", &pid.to_string()])
+        .args(["/T", "/F", "/PID", &child.id().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
@@ -209,14 +123,12 @@ mod windows_tree {
 /// 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`]),
-/// 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.
+/// 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.
 pub fn host_env(cmd: &mut Command) -> &mut Command {
    let fixes = child_env_changes();
-    let shell: Vec<_> = shell_env().collect();
-    if fixes.is_empty() && shell.is_empty() {
+    if fixes.is_empty() {
        return cmd;
    }
    let explicit: Vec<OsString> = cmd.get_envs().map(|(k, _)| k.to_owned()).collect();
@@ -226,9 +138,6 @@ 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
 }

@@ -245,13 +154,12 @@ 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`]), the login shell's value
-/// included when this process lacks the variable.
+/// [`std::env::var_os`] as a child should see it (see [`host_env`]).
 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).or_else(|| shell_env().find(|(k, _)| k == key).map(|(_, v)| v)),
+        None => std::env::var_os(key),
    }
 }

@@ -299,11 +207,9 @@ fn appimage_fixes() -> Vec<(OsString, Option<OsString>)> {
 const APPIMAGE_LAUNCH_VARS: [&str; 4] = ["APPDIR", "APPIMAGE", "ARGV0", "OWD"];

 /// What to change in `vars` (an environment) so a child sees the host's environment rather
-/// than the AppImage's: every `:`-separated entry inside `$APPDIR` — or inside *any*
-/// AppImage mount, since an in-app update restart inherits the previous mount's entries
-/// alongside the new one — is dropped (a saved `<NAME>_ORIG` wins when present),
-/// variables left empty are removed, and so are the runtime's own launch variables.
-/// Nothing changes when `APPDIR` is not set.
+/// than the AppImage's: every `:`-separated entry inside `$APPDIR` is dropped (a saved
+/// `<NAME>_ORIG` wins when present), variables left empty are removed, and so are the
+/// runtime's own launch variables. Nothing changes when `APPDIR` is not set.
 fn appimage_env_fixes(vars: &[(OsString, OsString)]) -> Vec<(OsString, Option<OsString>)> {
    let get = |name: &str| vars.iter().find(|(k, _)| k == name).map(|(_, v)| v);
    let Some(appdir) =
@@ -311,12 +217,7 @@ fn appimage_env_fixes(vars: &[(OsString, OsString)]) -> Vec<(OsString, Option<Os
    else {
        return Vec::new();
    };
-    let inside = |entry: &str| {
-        let own = entry.strip_prefix(appdir).is_some_and(|rest| rest.is_empty() || rest.starts_with('/'));
-        // AppImages extract to `/tmp/.mount_<name>`; an entry under another mount is
-        // another image's (e.g. the pre-update one a restart inherited), never the host's.
-        own || entry.starts_with("/tmp/.mount_")
-    };
+    let inside = |entry: &str| entry.strip_prefix(appdir).is_some_and(|rest| rest.is_empty() || rest.starts_with('/'));
    let mut fixes = Vec::new();
    for (key, value) in vars {
        let (Some(name), Some(value)) = (key.to_str(), value.to_str()) else { continue };
@@ -671,15 +572,6 @@ 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"));
@@ -722,7 +614,7 @@ mod tests {
            ("PATH", "/tmp/.mount_OpenIDabc/usr/bin/:/tmp/.mount_OpenIDabc/usr/sbin/:/usr/local/bin:/usr/bin"),
            ("XDG_DATA_DIRS", "/tmp/.mount_OpenIDabc/usr/share:/usr/share:/usr/local/share:/usr/share"),
            ("HOME", "/home/me"),
-            ("JAVA_HOME", "/opt/jdk"),
+            ("JAVA_HOME", "/tmp/.mount_OpenIDabcdef/jdk"),
        ]);
        assert_eq!(
            got,
@@ -735,27 +627,6 @@ mod tests {
        );
    }

-    #[test]
-    fn entries_of_a_previous_updates_mount_are_dropped() {
-        // An in-app update restart inherits the old mount's entries: a child's curl
-        // must not load the old image's libraries (they can still be mounted).
-        let got = fixes(&[
-            ("APPDIR", "/tmp/.mount_OpenIDjIlFFA"),
-            ("LD_LIBRARY_PATH", "/tmp/.mount_OpenIDjIlFFA/usr/lib/:/tmp/.mount_OpenIDdaNGfM/usr/lib/:/usr/local/lib"),
-            ("PATH", "/tmp/.mount_OpenIDjIlFFA/usr/bin/:/tmp/.mount_OpenIDdaNGfM/usr/bin/:/usr/bin"),
-            ("GIO_MODULE_DIR", "/tmp/.mount_OpenIDdaNGfM/usr/lib/gio/modules"),
-        ]);
-        assert_eq!(
-            got,
-            [
-                fix("APPDIR", None),
-                fix("LD_LIBRARY_PATH", Some("/usr/local/lib")),
-                fix("PATH", Some("/usr/bin")),
-                fix("GIO_MODULE_DIR", None),
-            ]
-        );
-    }
-
    #[test]
    fn variables_left_empty_are_removed() {
        // AppRun prepends to an unset variable, leaving a trailing `:`; hooks set single paths.
@@ -1,275 +0,0 @@
-//! Shared filesystem rules for discovering builds and resolving their owners.
-
-use std::collections::HashSet;
-use std::path::{Component, Path, PathBuf};
-
-pub const SEARCH_DEPTH: usize = 3;
-
-pub fn children(dir: &Path) -> Vec<PathBuf> {
-    let Ok(entries) = std::fs::read_dir(dir) else { return Vec::new() };
-    let mut dirs: Vec<_> = entries
-        .flatten()
-        .filter(|entry| {
-            if !entry.file_type().is_ok_and(|kind| kind.is_dir()) {
-                return false;
-            }
-            let name = entry.file_name();
-            let name = name.to_string_lossy();
-            !name.starts_with('.')
-                && !matches!(
-                    name.as_ref(),
-                    "node_modules" | "target" | "build" | "dist" | "vendor" | "out" | "bin" | "obj" | "venv"
-                )
-        })
-        .map(|entry| entry.path())
-        .collect();
-    dirs.sort();
-    dirs
-}
-
-pub fn discover(root: &Path, markers: &[&str]) -> Vec<PathBuf> {
-    discover_matching(root, SEARCH_DEPTH, true, |dir| markers.iter().any(|marker| dir.join(marker).is_file()))
-}
-
-pub fn discover_matching(
-    root: &Path,
-    max_depth: usize,
-    stop_at_match: bool,
-    marked: impl Fn(&Path) -> bool,
-) -> Vec<PathBuf> {
-    discover_matching_cancellable(root, max_depth, stop_at_match, &crate::CancellationToken::new(), marked)
-}
-
-pub fn discover_matching_cancellable(
-    root: &Path,
-    max_depth: usize,
-    stop_at_match: bool,
-    cancel: &crate::CancellationToken,
-    marked: impl Fn(&Path) -> bool,
-) -> Vec<PathBuf> {
-    let mut found = Vec::new();
-    let mut pending = vec![(root.to_path_buf(), 0)];
-    while let Some((dir, depth)) = pending.pop() {
-        if cancel.is_cancelled() {
-            break;
-        }
-        if marked(&dir) {
-            found.push(dir.clone());
-            if stop_at_match {
-                continue;
-            }
-        }
-        // A source folder may itself be a build root (e.g. src/pom.xml), but
-        // source trees without their own build marker are never searched.
-        let source = dir.join("src");
-        if source.is_dir() && !source.is_symlink() && marked(&source) {
-            found.push(source);
-        }
-        if depth < max_depth {
-            pending.extend(
-                children(&dir)
-                    .into_iter()
-                    .rev()
-                    .filter(|child| !child.ends_with("src"))
-                    .map(|child| (child, depth + 1)),
-            );
-        }
-    }
-    found.sort();
-    found.dedup();
-    found
-}
-
-/// Expands workspace member patterns one level deep: `dir`, `dir/*`, `dir/**`.
-pub fn expand_members(root: &Path, patterns: &[String], marker: &str) -> Vec<PathBuf> {
-    let mut dirs = Vec::new();
-    for pattern in patterns {
-        let pattern = pattern.trim().trim_start_matches("./").trim_end_matches('/');
-        if pattern.is_empty() || pattern.starts_with('!') {
-            continue;
-        }
-        let base = pattern.strip_suffix("/**").or_else(|| pattern.strip_suffix("/*"));
-        match base {
-            Some(base) if !base.contains('*') => {
-                dirs.extend(children(&root.join(base)).into_iter().filter(|d| d.join(marker).is_file()))
-            }
-            None if !pattern.contains('*') => {
-                let dir = root.join(pattern);
-                if dir.join(marker).is_file() {
-                    dirs.push(dir);
-                }
-            }
-            _ => {}
-        }
-    }
-    let mut seen = HashSet::new();
-    dirs.retain(|d| seen.insert(d.clone()));
-    dirs
-}
-
-pub fn node_workspace_members(root: &Path) -> Vec<PathBuf> {
-    let package = std::fs::read(root.join("package.json"))
-        .ok()
-        .and_then(|bytes| serde_json::from_slice::<serde_json::Value>(&bytes).ok())
-        .unwrap_or_default();
-    expand_members(root, &node_workspace_patterns(root, &package), "package.json")
-}
-
-fn node_workspace_patterns(root: &Path, pkg: &serde_json::Value) -> Vec<String> {
-    let mut patterns: Vec<String> = Vec::new();
-    let ws = pkg.get("workspaces");
-    let list = ws
-        .and_then(serde_json::Value::as_array)
-        .or_else(|| ws.and_then(|w| w.get("packages")).and_then(serde_json::Value::as_array));
-    if let Some(list) = list {
-        patterns.extend(list.iter().filter_map(serde_json::Value::as_str).map(str::to_owned));
-    }
-    if let Ok(yaml) = std::fs::read_to_string(root.join("pnpm-workspace.yaml")) {
-        let mut in_packages = false;
-        for line in yaml.lines() {
-            let trimmed = line.trim();
-            if trimmed.is_empty() || trimmed.starts_with('#') {
-                continue;
-            }
-            if !line.starts_with([' ', '\t', '-']) {
-                in_packages = trimmed.starts_with("packages:");
-                continue;
-            }
-            if in_packages && let Some(item) = trimmed.strip_prefix('-') {
-                let item = item.split(" #").next().unwrap_or_default().trim().trim_matches(['"', '\'']);
-                patterns.push(item.to_owned());
-            }
-        }
-    }
-    patterns
-}
-
-/// The closest package manager declaration or lockfile, shared by build and run.
-pub fn package_manager(root: &Path) -> &'static str {
-    for dir in root.ancestors() {
-        let package = std::fs::read(dir.join("package.json"))
-            .ok()
-            .and_then(|bytes| serde_json::from_slice::<serde_json::Value>(&bytes).ok());
-        if let Some(pm) = package.as_ref().and_then(|p| p.get("packageManager")).and_then(|p| p.as_str()) {
-            match pm.split('@').next().unwrap_or_default() {
-                "pnpm" => return "pnpm",
-                "yarn" => return "yarn",
-                "bun" => return "bun",
-                "npm" => return "npm",
-                _ => {}
-            }
-        }
-        for (marker, pm) in [
-            ("pnpm-lock.yaml", "pnpm"),
-            ("yarn.lock", "yarn"),
-            ("bun.lock", "bun"),
-            ("bun.lockb", "bun"),
-            ("package-lock.json", "npm"),
-        ] {
-            if dir.join(marker).is_file() {
-                return pm;
-            }
-        }
-    }
-    "npm"
-}
-
-pub fn resolve(root: &Path, path: &Path) -> PathBuf {
-    let mut out = PathBuf::new();
-    for component in root.join(path).components() {
-        match component {
-            Component::CurDir => {}
-            Component::ParentDir if out.file_name().is_some() => {
-                out.pop();
-            }
-            component => out.push(component),
-        }
-    }
-    out
-}
-
-pub fn relative(root: &Path, path: &Path) -> PathBuf {
-    let path = resolve(root, path);
-    path.strip_prefix(resolve(root, Path::new(""))).unwrap_or(&path).to_path_buf()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn package_manager_declarations_are_shared_by_build_and_run() {
-        let temp = tempfile::tempdir().unwrap();
-        std::fs::write(temp.path().join("pnpm-lock.yaml"), "").unwrap();
-        let child = temp.path().join("packages/web");
-        std::fs::create_dir_all(&child).unwrap();
-        assert_eq!(package_manager(&child), "pnpm");
-        std::fs::write(child.join("package.json"), r#"{"packageManager":"[email protected]"}"#).unwrap();
-        assert_eq!(package_manager(&child), "yarn");
-    }
-
-    #[test]
-    fn discovery_has_one_depth_boundary_and_exclusion_policy_for_all_families() {
-        let temp = tempfile::tempdir().unwrap();
-        let root = temp.path();
-        let markers = [
-            "package.json",
-            "Cargo.toml",
-            "go.mod",
-            "pom.xml",
-            "build.gradle.kts",
-            "pyproject.toml",
-            "composer.json",
-            "Gemfile",
-            "CMakeLists.txt",
-            "project.godot",
-            "deno.json",
-            "Makefile",
-            "justfile",
-        ];
-        for marker in markers {
-            for dir in [
-                "apps/one",
-                "services/backend/two",
-                "src",
-                "a/b/c/src",
-                "too/deep/to/find",
-                "node_modules/ignored",
-                "target/ignored",
-                "build/ignored",
-                "vendor/ignored",
-                ".hidden",
-                "src/ignored",
-            ] {
-                let path = root.join(dir).join(marker);
-                std::fs::create_dir_all(path.parent().unwrap()).unwrap();
-                std::fs::write(path, "").unwrap();
-            }
-            assert_eq!(
-                discover(root, &[marker]),
-                ["a/b/c/src", "apps/one", "services/backend/two", "src"].map(|dir| root.join(dir))
-            );
-        }
-        std::fs::write(root.join("Cargo.toml"), "").unwrap();
-        assert_eq!(discover(root, &["Cargo.toml"]), [root]);
-    }
-
-    #[cfg(unix)]
-    #[test]
-    fn discovery_never_follows_directory_symlinks() {
-        let temp = tempfile::tempdir().unwrap();
-        std::fs::create_dir(temp.path().join("real")).unwrap();
-        std::fs::write(temp.path().join("real/go.mod"), "").unwrap();
-        std::os::unix::fs::symlink(temp.path().join("real"), temp.path().join("alias")).unwrap();
-        assert_eq!(discover(temp.path(), &["go.mod"]), [temp.path().join("real")]);
-    }
-
-    #[test]
-    fn paths_keep_component_boundaries_and_external_roots() {
-        let temp = tempfile::tempdir().unwrap();
-        let root = temp.path().join("workspace");
-        assert_eq!(relative(&root, &root.join("apps/../api")), Path::new("api"));
-        assert_eq!(relative(&root, &temp.path().join("workspace-other")), temp.path().join("workspace-other"));
-        assert_eq!(resolve(&root, Path::new("./api/../web")), root.join("web"));
-    }
-}
@@ -1,5 +1,5 @@
-//! Settings of remote work: SSH configurations, SFTP deployment and run
-//! targets (SSH, Docker, Compose). The fields hang off `Settings` in `settings.rs`.
+//! Settings of remote work: SSH configurations, SFTP deployment and SSH run
+//! targets. The fields hang off `Settings` in `settings.rs`.

 use serde::{Deserialize, Serialize};
 use specta::Type;
@@ -140,55 +140,22 @@ pub struct DeploymentMapping {
    pub web: String,
 }

-/// Where a run target runs configurations.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub enum RunTargetKind {
-    /// Another machine over SSH, the project synchronised to its folder.
-    #[default]
-    Ssh,
-    /// A new container of an image (`docker run --rm`), the project bind-mounted.
-    Docker,
-    /// A new container of a Compose service (`docker compose run --rm`).
-    Compose,
-}
-
-/// Build, Execution, Deployment › Run Targets: run configurations on another machine
-/// or in a container.
+/// Build, Execution, Deployment › Run Targets: run configurations on another machine.
 #[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
 #[serde(default, rename_all = "camelCase")]
 pub struct RunTarget {
-    pub kind: RunTargetKind,
    pub id: String,
    pub name: String,
-    /// [`SshConfiguration::id`] (SSH).
+    /// [`SshConfiguration::id`].
    pub ssh_config: String,
-    /// Remote folder the project is synchronised to and run from (SSH).
+    /// Remote folder the project is synchronised to and run from.
    pub project_root: String,
-    /// Upload changed project files before each run (SSH).
+    /// Upload changed project files before each run.
    pub sync_before_run: bool,
    /// Interpreters on the target; empty = the one on the remote `PATH`.
    pub python: String,
    pub node: String,
    pub java: String,
-    /// Id of a Docker connection of the Services tool window (Docker, Compose);
-    /// empty = the CLI's own daemon.
-    pub docker_connection: String,
-    /// Image to run (Docker).
-    pub image: String,
-    /// Compose files, relative to the project; empty = the project's default one (Compose).
-    pub compose_files: Vec<String>,
-    /// Service to run (Compose).
-    pub service: String,
-    /// Where the project is in the container; empty = `/workspaces/<folder>` (Docker),
-    /// the service's bind mount of the project (Compose).
-    pub container_root: String,
-    /// Published ports, as `docker run --publish` takes them (`8000:8000`).
-    pub ports: Vec<String>,
-    /// More options for `docker run` / `docker compose run`, shell-like quoted.
-    pub run_options: String,
-    /// Run as the image's user instead of the project folder's owner (Linux).
-    pub image_user: bool,
 }

 #[cfg(test)]
@@ -209,24 +176,4 @@ mod deployment_tests {
            );
        }
    }
-
-    #[test]
-    fn run_target_kind_defaults_to_ssh_and_round_trips() {
-        let legacy: RunTarget =
-            serde_json::from_str(r#"{"id":"t","name":"Build box","sshConfig":"ssh","projectRoot":"/srv"}"#).unwrap();
-        assert_eq!((legacy.kind, legacy.ssh_config.as_str()), (RunTargetKind::Ssh, "ssh"));
-        let docker = RunTarget {
-            kind: RunTargetKind::Compose,
-            docker_connection: "local".into(),
-            compose_files: vec!["compose.dev.yaml".into()],
-            service: "web".into(),
-            ports: vec!["8000:8000".into()],
-            image_user: true,
-            ..legacy
-        };
-        let json = serde_json::to_value(&docker).unwrap();
-        assert_eq!(json["kind"], "compose");
-        assert_eq!(json["composeFiles"], serde_json::json!(["compose.dev.yaml"]));
-        assert_eq!(serde_json::from_value::<RunTarget>(json).unwrap(), docker);
-    }
 }
@@ -157,16 +157,6 @@ 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 {
@@ -180,8 +170,6 @@ impl Default for LanguageServerSettings {
            settings: None,
            languages: Vec::new(),
            root_markers: Vec::new(),
-            features: None,
-            code_action_kinds: None,
        }
    }
 }
@@ -268,8 +256,6 @@ pub struct GeneralSettings {
    pub power_save_mode: bool,
    /// File › Rename Project… (project layer): the name shown for the project; empty = its folder name.
    pub project_name: String,
-    /// Where updates come from: `auto` (the CNB mirror for the Chinese UI, else GitHub) | `github` | `cnb`.
-    pub update_source: String,
 }

 impl Default for GeneralSettings {
@@ -284,7 +270,6 @@ impl Default for GeneralSettings {
            date_format: DateFormatSettings::default(),
            power_save_mode: false,
            project_name: String::new(),
-            update_source: "auto".into(),
        }
    }
 }
@@ -354,7 +339,6 @@ pub struct AppearanceSettings {
    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).
@@ -367,8 +351,6 @@ pub struct AppearanceSettings {
    pub red_green_vision: bool,
    pub different_tool_window_background: bool,
    pub compact_mode: bool,
-    /// IDEA "Use smaller indents in trees": tool window trees indent less per level.
-    pub small_tree_indents: bool,
    pub full_path_in_title: bool,
    pub project_colors_in_toolbar: bool,
    pub dnd_with_alt_only: bool,
@@ -392,24 +374,6 @@ 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 {
@@ -430,7 +394,6 @@ impl Default for AppearanceSettings {
            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(),
@@ -439,7 +402,6 @@ impl Default for AppearanceSettings {
            red_green_vision: false,
            different_tool_window_background: false,
            compact_mode: false,
-            small_tree_indents: false,
            full_path_in_title: false,
            project_colors_in_toolbar: true,
            dnd_with_alt_only: false,
@@ -607,7 +569,7 @@ impl Default for FileSettings {
    }
 }

-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
 #[serde(default, rename_all = "camelCase")]
 pub struct LanguagesSettings {
    pub python: PythonSettings,
@@ -618,34 +580,11 @@ pub struct LanguagesSettings {
    pub typescript: TypeScriptSettings,
    pub prettier: ExternalFormatterSettings,
    pub oxfmt: ExternalFormatterSettings,
-    pub ruff: ExternalFormatterSettings,
    pub java: JavaSettings,
    pub ruby: RubySettings,
    pub markdown: MarkdownSettings,
 }

-impl Default for LanguagesSettings {
-    fn default() -> Self {
-        Self {
-            python: PythonSettings::default(),
-            node: NodeSettings::default(),
-            php: PhpSettings::default(),
-            rust: RustSettings::default(),
-            go: GoSettings::default(),
-            typescript: TypeScriptSettings::default(),
-            prettier: ExternalFormatterSettings::default(),
-            oxfmt: ExternalFormatterSettings::default(),
-            ruff: ExternalFormatterSettings {
-                languages: vec!["python".into()],
-                ..ExternalFormatterSettings::default()
-            },
-            java: JavaSettings::default(),
-            ruby: RubySettings::default(),
-            markdown: MarkdownSettings::default(),
-        }
-    }
-}
-
 /// Languages & Frameworks › Markdown. Like IDEA's, it is application-level only.
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
 #[serde(default, rename_all = "camelCase")]
@@ -659,7 +598,6 @@ impl LanguagesSettings {
        match tool {
            ExternalFormatter::Prettier => &self.prettier,
            ExternalFormatter::Oxfmt => &self.oxfmt,
-            ExternalFormatter::Ruff => &self.ruff,
        }
    }
 }
@@ -670,7 +608,6 @@ impl LanguagesSettings {
 pub enum ExternalFormatter {
    Prettier,
    Oxfmt,
-    Ruff,
 }

 impl ExternalFormatter {
@@ -679,19 +616,16 @@ impl ExternalFormatter {
        match self {
            Self::Prettier => "prettier",
            Self::Oxfmt => "oxfmt",
-            Self::Ruff => "ruff",
        }
    }
 }

-/// An external formatter (Prettier, oxfmt, Ruff) and the languages it formats.
+/// An external formatter (Prettier, oxfmt) and the languages it formats.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
 #[serde(default, rename_all = "camelCase")]
 pub struct ExternalFormatterSettings {
-    /// Empty path: project node_modules (Prettier/oxfmt), managed installation, then PATH.
+    /// Empty path: project node_modules, managed installation, then PATH.
    pub path: String,
-    /// Ruff only: directory containing its configuration, or a configuration file.
-    pub configuration_directory: String,
    pub languages: Vec<String>,
    /// Prefer this formatter even when a language server offers formatting.
    pub prefer: bool,
@@ -702,7 +636,6 @@ impl Default for ExternalFormatterSettings {
    fn default() -> Self {
        Self {
            path: String::new(),
-            configuration_directory: String::new(),
            languages: [
                "markdown",
                "yaml",
@@ -748,19 +681,6 @@ 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>,
-    /// PHPStan configuration file for checking saved files; empty = the `phpstan.neon`,
-    /// `phpstan.neon.dist` or `phpstan.dist.neon` PHPStan finds in the project root. Absolute,
-    /// `~/`, or relative to the project.
-    pub phpstan_config: String,
 }

 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
@@ -850,8 +770,6 @@ pub struct JavaSettings {
    /// Project JDK home; empty = per module, the installed JDK matching the
    /// Java version it targets.
    pub jdk: String,
-    /// Project Java language level (`8`, `11`, `17`, `21`, `25`); empty = SDK default.
-    pub language_level: String,
    /// JDK home the Java language server (jdtls) runs on, apart from the project
    /// JDK (IDEA's "JDK for importer"); empty = the project JDK when new enough,
    /// else the first installed one that is.
@@ -869,8 +787,6 @@ pub struct JavaSettings {
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
 #[serde(default, rename_all = "camelCase")]
 pub struct GradleSettings {
-    /// Linked build directories; absent preserves automatic discovery, empty unlinks all builds.
-    pub linked_projects: Option<Vec<String>>,
    /// Empty = Project JDK; otherwise a JDK home.
    pub jvm: String,
    pub distribution: GradleDistribution,
@@ -905,42 +821,14 @@ pub enum GradleDistribution {
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
 #[serde(default, rename_all = "camelCase")]
 pub struct MavenSettings {
-    /// JDK home used to run Maven; empty = Project JDK, else the POM's Java version.
-    pub runner_jre: String,
    /// Project-relative root POMs removed from the Maven project model.
    pub unlinked_projects: Vec<String>,
-    /// Project-relative POMs outside the root reactor added as independent top-level projects.
-    pub linked_projects: Vec<String>,
    /// Maven home (or its `mvn` executable); empty = the project's `mvnw`, else `mvn` on `PATH`.
    pub home: String,
    /// User `settings.xml` (`-s`); empty = `~/.m2/settings.xml`.
    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,
-    /// Thread count of Maven builds (`-T`): a number of threads (`4`) or a core
-    /// multiplier (`2C`, `2.5C`); empty = Maven's default (one thread per module).
-    pub threads: String,
-}
-
-impl MavenSettings {
-    /// The `-T` value when it is one Maven accepts: a thread count (`4`) or a
-    /// core multiplier with an optional decimal fraction (`1C`, `2.5C`).
-    /// Anything else is dropped: a bad `-T` would make every Maven run fail.
-    pub fn thread_count(&self) -> Option<&str> {
-        let value = self.threads.trim();
-        let number = value.strip_suffix('C').unwrap_or(value);
-        let mut decimal = number.split('.');
-        let well_formed = number.parse::<f64>().is_ok_and(|n| n > 0.0)
-            && decimal.clone().count() <= 2
-            && decimal.all(|part| !part.is_empty() && part.chars().all(|c| c.is_ascii_digit()));
-        well_formed.then_some(value)
-    }
 }

 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
@@ -957,98 +845,6 @@ impl Default for TypeScriptSettings {
    }
 }

-/// Dependency scope for a module dependency or project library (IDEA's Modules › Dependencies).
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub enum DependencyScope {
-    #[default]
-    Compile,
-    Test,
-    Runtime,
-    Provided,
-}
-
-/// A project-level library (Project Structure › Libraries).
-#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[serde(default, rename_all = "camelCase")]
-pub struct ProjectLibrary {
-    pub name: String,
-    /// Class archives (`.jar`) or class directories.
-    pub classes: Vec<String>,
-    /// Source archives (`-sources.jar`, `.zip`) or source directories.
-    pub sources: Vec<String>,
-    /// Documentation archives (`-javadoc.jar`) or directories.
-    pub javadocs: Vec<String>,
-    pub scope: DependencyScope,
-}
-
-/// Dependency entry of a module (Project Structure › Modules › Dependencies).
-#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[serde(default, rename_all = "camelCase")]
-pub struct ModuleDependency {
-    /// `"library"` (references a `ProjectLibrary` by name or path) or `"module"` (references another module).
-    pub kind: String,
-    pub target: String,
-    pub scope: DependencyScope,
-    pub exported: bool,
-}
-
-/// Per-module Project Structure overrides (SDK, language level, output paths, dependencies).
-#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[serde(default, rename_all = "camelCase")]
-pub struct ModuleStructureSettings {
-    /// Module SDK home override; empty = inherit Project SDK.
-    pub jdk: String,
-    /// Module language level override; empty = inherit Project language level.
-    pub language_level: String,
-    /// Module compiler output directory override; empty = inherit Project compiler output.
-    pub compiler_output: String,
-    /// Module test compiler output directory override; empty = default.
-    pub test_compiler_output: String,
-    /// Additional module dependencies.
-    pub dependencies: Vec<ModuleDependency>,
-}
-
-/// Framework facet attached to a module (Project Structure › Facets).
-#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[serde(default, rename_all = "camelCase")]
-pub struct FacetConfig {
-    /// `"web"` | `"spring"` | `"jpa"`.
-    pub kind: String,
-    /// Module relative path (`"."` for root module).
-    pub module: String,
-    /// Deployment descriptor path (e.g. `src/main/webapp/WEB-INF/web.xml`, `src/main/resources/META-INF/persistence.xml`).
-    pub descriptor: String,
-    /// Web resource root directory for Web facets (e.g. `src/main/webapp`).
-    pub web_root: String,
-}
-
-/// Packaging type of a Project Structure artifact.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub enum ArtifactKind {
-    #[default]
-    Jar,
-    War,
-    WarExploded,
-}
-
-/// Packaging artifact definition (Project Structure › Artifacts).
-#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[serde(default, rename_all = "camelCase")]
-pub struct ArtifactConfig {
-    pub name: String,
-    pub kind: ArtifactKind,
-    /// Module relative path (`"."` for root module).
-    pub module: String,
-    /// Output directory (relative to project root or absolute).
-    pub output_directory: String,
-    /// Main class for executable JAR artifacts.
-    pub main_class: String,
-    /// Project library names included in the packaged artifact (`WEB-INF/lib` or JAR manifest).
-    pub include_libraries: Vec<String>,
-}
-
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
 #[serde(default, rename_all = "camelCase")]
 pub struct ProjectStructureSettings {
@@ -1065,28 +861,9 @@ pub struct ProjectStructureSettings {
    pub content_roots: Vec<String>,
    /// "Exclude files": `;`-separated name patterns (`*.log;tmp*`) excluded at any depth.
    pub exclude_files: String,
-    /// Project compiler output directory (relative to project root or absolute; empty = default).
-    pub compiler_output: String,
-    /// Per-module SDK, language level, output paths and dependency overrides, keyed by module relative path (`"."` for root).
-    pub modules: BTreeMap<String, ModuleStructureSettings>,
-    /// Project-level libraries (`JAR`s / class folders / source archives).
-    pub libraries: Vec<ProjectLibrary>,
-    /// Module framework facets (`web`, `spring`, `jpa`).
-    pub facets: Vec<FacetConfig>,
-    /// Packaging artifacts (`jar`, `war`, `warExploded`).
-    pub artifacts: Vec<ArtifactConfig>,
 }

 impl ProjectStructureSettings {
-    /// Overrides belong to the module's full path, never just its directory name.
-    pub fn module_settings(
-        &self,
-        root: &std::path::Path,
-        module: &std::path::Path,
-    ) -> Option<&ModuleStructureSettings> {
-        self.modules.iter().find_map(|(key, settings)| (root.join(key) == module).then_some(settings))
-    }
-
    /// The "Exclude files" name patterns.
    pub fn exclude_file_patterns(&self) -> Vec<String> {
        self.exclude_files.split(';').map(str::trim).filter(|p| !p.is_empty()).map(str::to_owned).collect()
@@ -1142,36 +919,6 @@ 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();
@@ -1267,81 +1014,12 @@ mod tests {
        assert_eq!(s.file_excludes(), vec!["*.log", "tmp*"]);
        assert!(Settings::default().files.file_types.is_empty());
    }
-
-    #[test]
-    fn project_structure_modules_libraries_facets_and_artifacts_round_trip() {
-        let old: Settings = serde_json::from_str(r#"{"projectStructure":{"sourceRoots":["src"]}}"#).unwrap();
-        assert!(old.project_structure.compiler_output.is_empty());
-        assert!(old.project_structure.modules.is_empty());
-        assert!(old.project_structure.libraries.is_empty());
-        assert!(old.project_structure.facets.is_empty());
-        assert!(old.project_structure.artifacts.is_empty());
-        assert!(old.languages.java.language_level.is_empty());
-
-        let mut settings = Settings::default();
-        settings.languages.java.language_level = "21".into();
-        settings.project_structure.compiler_output = "out/production".into();
-        settings.project_structure.modules.insert(
-            "backend".into(),
-            ModuleStructureSettings {
-                jdk: "/opt/jdk-21".into(),
-                language_level: "21".into(),
-                compiler_output: "backend/target/classes".into(),
-                test_compiler_output: "backend/target/test-classes".into(),
-                dependencies: vec![ModuleDependency {
-                    kind: "library".into(),
-                    target: "custom-lib".into(),
-                    scope: DependencyScope::Compile,
-                    exported: true,
-                }],
-            },
-        );
-        settings.project_structure.libraries.push(ProjectLibrary {
-            name: "custom-lib".into(),
-            classes: vec!["lib/custom.jar".into()],
-            sources: vec!["lib/custom-sources.jar".into()],
-            javadocs: Vec::new(),
-            scope: DependencyScope::Compile,
-        });
-        settings.project_structure.facets.push(FacetConfig {
-            kind: "web".into(),
-            module: "backend".into(),
-            descriptor: "src/main/webapp/WEB-INF/web.xml".into(),
-            web_root: "src/main/webapp".into(),
-        });
-        settings.project_structure.artifacts.push(ArtifactConfig {
-            name: "backend:war exploded".into(),
-            kind: ArtifactKind::WarExploded,
-            module: "backend".into(),
-            output_directory: "out/artifacts/backend_war_exploded".into(),
-            main_class: String::new(),
-            include_libraries: vec!["custom-lib".into()],
-        });
-
-        let value = serde_json::to_value(&settings).unwrap();
-        assert_eq!(value["languages"]["java"]["languageLevel"], "21");
-        assert_eq!(value["projectStructure"]["compilerOutput"], "out/production");
-        assert_eq!(value["projectStructure"]["artifacts"][0]["kind"], "warExploded");
-        let restored: Settings = serde_json::from_value(value).unwrap();
-        assert_eq!(restored, settings);
-    }
 }

 #[cfg(test)]
 mod maven_linkage_tests {
    use super::*;

-    #[test]
-    fn maven_runner_jre_defaults_and_round_trips() {
-        let old: MavenSettings = serde_json::from_str(r#"{"home":"/opt/maven"}"#).unwrap();
-        assert!(old.runner_jre.is_empty());
-        assert!(MavenSettings::default().runner_jre.is_empty());
-        let settings = MavenSettings { runner_jre: "/opt/jdk-21".into(), ..old };
-        let encoded = serde_json::to_string(&settings).unwrap();
-        assert!(encoded.contains(r#""runnerJre":"/opt/jdk-21""#));
-        assert_eq!(serde_json::from_str::<MavenSettings>(&encoded).unwrap(), settings);
-    }
-
    #[test]
    fn maven_linkage_defaults_and_round_trips() {
        let old: MavenSettings = serde_json::from_str(r#"{"home":"/opt/maven"}"#).unwrap();
@@ -1352,68 +1030,12 @@ 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);
-    }
-
-    #[test]
-    fn thread_count_takes_counts_and_core_multipliers_only() {
-        let threads = |t: &str| {
-            let m = MavenSettings { threads: t.into(), ..Default::default() };
-            m.thread_count().map(str::to_owned)
-        };
-        // Empty = Maven's default (one thread per module).
-        assert_eq!(threads("").as_deref(), None);
-        assert_eq!(threads("   ").as_deref(), None);
-        // A thread count, and a core multiplier whose fraction may be decimal.
-        assert_eq!(threads("4").as_deref(), Some("4"));
-        assert_eq!(threads(" 2 ").as_deref(), Some("2"));
-        assert_eq!(threads("1C").as_deref(), Some("1C"));
-        assert_eq!(threads("2.0C").as_deref(), Some("2.0C"));
-        assert_eq!(threads("0.5C").as_deref(), Some("0.5C"));
-        // Everything else a `-T` would make every Maven run reject is dropped.
-        assert_eq!(threads("abc").as_deref(), None);
-        assert_eq!(threads("4x").as_deref(), None);
-        assert_eq!(threads("0").as_deref(), None);
-        assert_eq!(threads("-4").as_deref(), None);
-        assert_eq!(threads("1e3").as_deref(), None);
-        assert_eq!(threads("2..5C").as_deref(), None);
-    }
-
-    #[test]
-    fn thread_count_round_trips_and_defaults_to_empty() {
-        // Old settings files predate the thread count; `serde(default)` keeps them loadable.
-        let old: MavenSettings = serde_json::from_str(r#"{"home":"/opt/maven"}"#).unwrap();
-        assert!(old.threads.is_empty() && old.thread_count().is_none());
-        let settings = MavenSettings { threads: "2C".into(), ..old };
-        let encoded = serde_json::to_string(&settings).unwrap();
-        assert!(encoded.contains("\"threads\":\"2C\""));
-        assert_eq!(serde_json::from_str::<MavenSettings>(&encoded).unwrap(), settings);
-    }
 }

 #[cfg(test)]
 mod gradle_settings_tests {
    use super::*;

-    #[test]
-    fn absent_and_explicitly_empty_gradle_links_remain_distinct() {
-        let automatic: GradleSettings = serde_json::from_str("{}").unwrap();
-        let unlinked: GradleSettings = serde_json::from_str(r#"{"linkedProjects":[]}"#).unwrap();
-        assert_eq!(automatic.linked_projects, None);
-        assert_eq!(unlinked.linked_projects, Some(vec![]));
-        let restored: GradleSettings = serde_json::from_str(&serde_json::to_string(&unlinked).unwrap()).unwrap();
-        assert_eq!(restored.linked_projects, Some(vec![]));
-    }
-
    #[test]
    fn defaults_and_round_trip() {
        let old: JavaSettings = serde_json::from_str(r#"{"jdk":"/jdk"}"#).unwrap();
@@ -1426,7 +1048,6 @@ mod gradle_settings_tests {
                home: "/gradle".into(),
                user_home: "/cache/gradle".into(),
                run_using: GradleRunUsing::Ide,
-                linked_projects: Some(vec!["backend".into(), "../shared".into()]),
            };
            let restored: Settings = serde_json::from_str(&serde_json::to_string(&settings).unwrap()).unwrap();
            assert_eq!(restored.languages.java.gradle, settings.languages.java.gradle);
@@ -30,21 +30,6 @@ pub fn search_path() -> OsString {
    std::env::join_paths(dirs).unwrap_or_default()
 }

-/// Ruby code printing where `gem install` puts executables: the Ruby's own `Gem.bindir`, which
-/// Homebrew's Ruby keeps off `PATH`, and the `--user-install` one.
-pub const RUBY_GEM_BIN_SCRIPT: &str = "puts Gem.bindir, File.join(Gem.user_dir, 'bin')";
-
-/// The directories [`RUBY_GEM_BIN_SCRIPT`] printed that exist.
-pub fn gem_bin_dirs(output: &str) -> Vec<PathBuf> {
-    let mut dirs: Vec<PathBuf> = Vec::new();
-    for dir in output.lines().map(str::trim).map(PathBuf::from) {
-        if dir.is_absolute() && dir.is_dir() && !dirs.contains(&dir) {
-            dirs.push(dir);
-        }
-    }
-    dirs
-}
-
 /// Resolves a command on the shared path, or an explicit path relative to `root`.
 pub fn find_command(command: &str, search: &OsStr, root: &Path) -> Option<PathBuf> {
    let path = Path::new(command);
@@ -143,7 +128,7 @@ fn nvm_bins(dir: &Path) -> Vec<PathBuf> {
 }

 /// `v22.10.1` as `[22, 10, 1]`: v22 is newer than v9, v20.10 newer than v20.9.
-pub fn version_key(name: &str) -> Vec<u64> {
+fn version_key(name: &str) -> Vec<u64> {
    name.trim_start_matches('v').split('.').map(|n| n.parse().unwrap_or(0)).collect()
 }

@@ -113,8 +113,6 @@ pub struct CommitSettings {
    pub body_limit: u32,
    pub show_right_margin: bool,
    pub wrap_at_margin: bool,
-    /// Plugin before-commit checks turned off (`<plugin id>/<check id>`); the rest run.
-    pub disabled_plugin_checks: Vec<String>,
 }

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

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

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

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

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

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

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

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

 [dependencies]
-futures.workspace = true
 tempfile.workspace = true
 ide-core.workspace = true
 ide-language.workspace = true
@@ -17,12 +16,8 @@ specta.workspace = true
 tokio = { workspace = true, features = ["net"] }
 parking_lot.workspace = true
 memchr = "2"
-portable-pty.workspace = true
 tracing.workspace = true

-[target.'cfg(unix)'.dependencies]
-libc = "0.2"
-
 [dev-dependencies]
 tracing-subscriber.workspace = true
 tokio = { workspace = true, features = ["net", "rt-multi-thread", "macros"] }
@@ -64,27 +64,21 @@ fn builtin(adapter: &str) -> Option<DebuggerConfig> {
            "codelldb",
            &["--port", PORT_PLACEHOLDER],
            "tcp",
-            "Install CodeLLDB in Settings › Languages & Frameworks › Language Servers",
+            "Install the CodeLLDB adapter (https://github.com/vadimcn/codelldb/releases) and put `codelldb` on PATH",
        ),
        "kotlin-debug-adapter" => cfg(
            "kotlin-debug-adapter",
            &[],
            "stdio",
-            "Install Kotlin Debug Adapter in Settings › Languages & Frameworks › Language Servers",
-        ),
-        // Windows installs `python.exe`; `python3.exe` there is at most a Store alias.
-        "debugpy" => cfg(
-            if cfg!(windows) { "python" } else { "python3" },
-            &["-m", "debugpy.adapter"],
-            "stdio",
-            "pip install debugpy",
+            "Install the Kotlin Debug Adapter from Settings > Language Servers",
        ),
+        "debugpy" => cfg("python3", &["-m", "debugpy.adapter"], "stdio", "pip install debugpy"),
        "js-debug" => cfg(
            "js-debug-adapter",
            // Without a host it listens on `localhost`, which may resolve to ::1 only.
            &[PORT_PLACEHOLDER, "127.0.0.1"],
            "tcp",
-            "Install JavaScript Debugger (vscode-js-debug) in Settings › Languages & Frameworks › Language Servers",
+            "Install vscode-js-debug's DAP server (js-debug-dap-*.tar.gz from https://github.com/microsoft/vscode-js-debug/releases) as `js-debug-adapter`",
        ),
        "delve" => cfg(
            "dlv",
@@ -96,7 +90,7 @@ fn builtin(adapter: &str) -> Option<DebuggerConfig> {
            "netcoredbg",
            &["--interpreter=vscode"],
            "stdio",
-            "Install netcoredbg (.NET debugger) in Settings › Languages & Frameworks › Language Servers",
+            "Install Samsung netcoredbg (https://github.com/Samsung/netcoredbg/releases)",
        ),
        "lldb-dap" => {
            cfg("lldb-dap", &[], "stdio", "Install LLVM's lldb-dap (brew install llvm; on macOS `xcrun -f lldb-dap`)")
@@ -196,18 +190,10 @@ fn managed_dirs(root: &Path) -> Vec<PathBuf> {
    dirs
 }

-/// The `PATH` an adapter runs with, unless its launch sets one: the search path language servers
-/// get, so what it starts in turn (js-debug's wrapper runs `node`, Delve runs `go build`) is
-/// found like Run finds it, even when the login shell's `PATH` didn't reach the app.
-fn adapter_path(env: &[(String, String)]) -> Option<std::ffi::OsString> {
-    let own = env.iter().any(|(k, _)| if cfg!(windows) { k.eq_ignore_ascii_case("PATH") } else { k == "PATH" });
-    (!own).then(ide_core::tool_path::search_path)
-}
-
 /// Directories searched for adapter binaries: managed tools first, then `PATH` and the usual install spots.
 fn search_dirs() -> Vec<PathBuf> {
    let mut dirs: Vec<PathBuf> = tools_root().map(|r| managed_dirs(&r)).unwrap_or_default();
-    dirs.extend(std::env::split_paths(&ide_core::tool_path::search_path()));
+    dirs.extend(std::env::var_os("PATH").map(|p| std::env::split_paths(&p).collect::<Vec<_>>()).unwrap_or_default());
    if let Some(home) = std::env::var_os("HOME").map(PathBuf::from) {
        for rel in [".cargo/bin", ".local/bin", "go/bin", ".dotnet/tools", ".bun/bin", ".npm-global/bin", ".volta/bin"]
        {
@@ -472,9 +458,6 @@ impl AdapterLauncher for ProcessLauncher {
                None => args,
            };
            let mut cmd = Command::new(&binary);
-            if let Some(path) = adapter_path(&spec.env) {
-                cmd.env("PATH", path);
-            }
            ide_core::process::prepare(cmd.as_std_mut());
            cmd.args(&args)
                .envs(spec.env.iter().map(|(k, v)| (k, v)))
@@ -603,21 +586,6 @@ async fn connect_with_retries(
 mod tests {
    use super::*;

-    #[test]
-    fn adapters_run_on_the_tool_search_path() {
-        let search = ide_core::tool_path::search_path();
-        assert_eq!(adapter_path(&[]), Some(search.clone()));
-        assert_eq!(adapter_path(&[("GOFLAGS".into(), "-mod=mod".into())]), Some(search));
-        // A launch that sets its own (a selected Go SDK's bin first) keeps it.
-        assert_eq!(adapter_path(&[("PATH".into(), "/sdk/go/bin:/usr/bin".into())]), None);
-        // The search path reaches the usual install spots even when this process's `PATH` doesn't.
-        #[cfg(unix)]
-        {
-            let dirs: Vec<PathBuf> = std::env::split_paths(&ide_core::tool_path::search_path()).collect();
-            assert!(dirs.contains(&PathBuf::from("/usr/local/bin")), "{dirs:?}");
-        }
-    }
-
    #[tokio::test]
    async fn program_output_is_forwarded_without_the_adapter_banner() {
        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
@@ -694,7 +662,7 @@ mod tests {
        assert!(find_binary("definitely-not-a-real-binary-openidea", &spec.cwd).is_none());
        let err = missing(&spec);
        assert_eq!(err.kind, ide_core::error::ErrorKind::Unavailable);
-        assert!(err.message.contains("Settings › Languages & Frameworks › Language Servers"));
+        assert!(err.message.contains("netcoredbg/releases"));
    }

    #[tokio::test]
@@ -19,7 +19,6 @@ mod session;

 use adapter::{AdapterLauncher, AdapterSpec, ProcessLauncher};
 use connection::{Connection, DapError};
-use futures::future::join_all;
 use ide_core::{DebugSessionId, IdeError, IdeResult, SharedSink};
 use ide_language::LanguageRegistry;
 use parking_lot::Mutex;
@@ -213,19 +212,6 @@ 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 {
@@ -301,25 +287,6 @@ pub struct DebugManager {
    exception_choices: Mutex<BTreeMap<String, bool>>,
    function_breakpoints: Mutex<Vec<FunctionBreakpoint>>,
    data_breakpoints: Mutex<Vec<DataBreakpoint>>,
-    /// In-flight stops, by session: a second Stop sets `stop_force`, the waiting one kills.
-    stopping: Mutex<HashMap<DebugSessionId, Arc<Session>>>,
-}
-
-/// Whether the debugged project depends on the Flutter SDK, so it must go
-/// through `flutter debug_adapter` instead of the plain Dart one.
-///
-/// `dart debug_adapter` cannot start a program that imports `dart:ui`, and only
-/// the Flutter adapter answers `hotReload` / `hotRestart`. `dir` is the launch
-/// `cwd`; the program's own directory is tried first because a module inside a
-/// larger repository has its `pubspec.yaml` above the program, not above `cwd`.
-fn is_flutter_project(dir: &Path, program: Option<&Path>) -> bool {
-    let mut start: Vec<&Path> = program.and_then(Path::parent).into_iter().collect();
-    start.push(dir);
-    start
-        .iter()
-        .filter_map(|d| d.ancestors().take(6).find(|a| a.join("pubspec.yaml").is_file()))
-        .filter_map(|root| std::fs::read_to_string(root.join("pubspec.yaml")).ok())
-        .any(|s| s.contains("sdk: flutter"))
 }

 fn no_session(s: DebugSessionId) -> IdeError {
@@ -513,18 +480,6 @@ pub(crate) fn capabilities_from(caps: &Value) -> DebugCapabilities {
    }
 }

-/// States of a file's line breakpoints that no session has been sent.
-fn unsent(breakpoints: &[Breakpoint]) -> Vec<BreakpointState> {
-    breakpoints
-        .iter()
-        .map(|b| BreakpointState {
-            line: b.line,
-            verified: false,
-            message: (!b.enabled).then(|| "Disabled".to_owned()),
-        })
-        .collect()
-}
-
 /// States for breakpoints no session has verified yet.
 fn unverified(enabled: impl Iterator<Item = bool>) -> Vec<BreakpointState> {
    enabled
@@ -532,34 +487,6 @@ fn unverified(enabled: impl Iterator<Item = bool>) -> Vec<BreakpointState> {
        .collect()
 }

-/// Delve compiles the debuggee to `__debug_bin` in the session's cwd (on Windows
-/// `__debug_bin.exe` plus `__debug_bin.exe<digits>` in DAP mode) and removes it on a
-/// graceful exit — a shutdown it doesn't always reach, so the files pile up. Sweep
-/// the leftovers once the session is down. Runs after `session_closed`, so Delve
-/// has already exited or been killed and holds no file locks; a leftover of a
-/// still-building run is removed on that run's own shutdown.
-fn remove_delve_binaries(cwd: &Path) {
-    let Ok(entries) = std::fs::read_dir(cwd) else { return };
-    for entry in entries.flatten() {
-        let name = entry.file_name();
-        let Some(name) = name.to_str() else { continue };
-        // Windows writes `__debug_bin.exe` (and `.exe<digits>` in DAP mode); other
-        // platforms keep the bare name. Suffixes like `.go` are user files.
-        let suffix = name.strip_prefix("__debug_bin");
-        let leftover = suffix.is_some_and(|s| {
-            s.is_empty()
-                || s == ".exe"
-                || (s.starts_with(".exe") && s[".exe".len()..].chars().all(|c| c.is_ascii_digit()))
-        });
-        if leftover
-            && entry.file_type().is_ok_and(|t| t.is_file())
-            && let Err(e) = std::fs::remove_file(entry.path())
-        {
-            tracing::debug!("could not remove Delve leftover {}: {e}", entry.path().display());
-        }
-    }
-}
-
 pub(crate) fn variable_from(v: &Value) -> Variable {
    let s = |k: &str| v.get(k).and_then(Value::as_str).map(str::to_owned);
    Variable {
@@ -589,7 +516,6 @@ impl DebugManager {
            exception_choices: Mutex::default(),
            function_breakpoints: Mutex::default(),
            data_breakpoints: Mutex::default(),
-            stopping: Mutex::default(),
        })
    }

@@ -631,10 +557,6 @@ impl DebugManager {
        custom_command: impl FnOnce(&str) -> Option<String>,
    ) -> IdeResult<DebugSessionId> {
        let mut arguments = launch_arguments(&config)?;
-        // An IDE-side marker (never sent to the adapter): the session is a Flutter
-        // one regardless of what the working directory holds.
-        let force_flutter =
-            arguments.as_object_mut().and_then(|o| o.remove("__flutter")).and_then(|v| v.as_bool()).unwrap_or(false);
        let cwd = config
            .cwd
            .clone()
@@ -654,27 +576,17 @@ 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),
-        // or with the launcher's when the debuggee runs through a manager (`uv run python`).
+        // debugpy: run the adapter with the debuggee's interpreter (venvs carry their own debugpy).
        if config.adapter == "debugpy" {
-            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),
+            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),
                _ => None,
            };
            if let Some(python) = python {
                spec.command = python;
            }
        }
-        // Flutter: a project depending on the Flutter SDK needs `flutter debug_adapter`
-        // (the Dart adapter cannot start a program importing `dart:ui`, and hot reload
-        // is Flutter-only). Plain Dart projects keep the configured `dart`.
-        if config.adapter == "dart" && spec.command == "dart" {
-            let program = arguments.get("program").and_then(Value::as_str).map(Path::new);
-            if force_flutter || is_flutter_project(&cwd, program) {
-                spec.command = "flutter".into();
-            }
-        }
        let id = DebugSessionId::next();
        let debug_server = take_debug_server(&mut arguments)?;
        if let Some(server) = &debug_server {
@@ -726,19 +638,8 @@ impl DebugManager {
        {
            arguments["project"] = json!(real);
        }
-        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(_) => {}
-            }
+        if config.adapter == "codelldb" && arguments.get("sourceLanguages").is_none() {
+            arguments["sourceLanguages"] = json!(["rust"]);
        }
        let port = debug_server.map(|s| s.port);
        self.start_session(id, owner, config.name, config.adapter, None, config.request, arguments, spec, port).await
@@ -921,20 +822,12 @@ impl DebugManager {
            let _ = tokio::time::timeout(INIT_TIMEOUT, initialized.wait_for(|v| *v)).await;
        }

-        // A fresh adapter has no breakpoints, so a file with none enabled needs no request; the
-        // others go out together, as VS Code sends them, instead of one round trip per file.
-        let (files, idle): (Vec<_>, Vec<_>) = self
-            .breakpoints
-            .lock()
-            .iter()
-            .map(|(p, b)| (p.clone(), b.clone()))
-            .partition(|(_, b)| b.iter().any(|b| b.enabled));
-        let sent = join_all(files.iter().map(|(path, bps)| s.send_breakpoints(path, bps, None))).await;
+        let files: Vec<(PathBuf, Vec<Breakpoint>)> =
+            self.breakpoints.lock().iter().map(|(p, b)| (p.clone(), b.clone())).collect();
        // Breakpoint states follow the owner's first session.
        let first = self.live_sessions().into_iter().find(|f| f.owner.key == s.owner.key).map(|f| f.id) == Some(s.id);
-        let idle = idle.into_iter().map(|(path, bps)| (path, Ok(unsent(&bps))));
-        for (path, result) in files.into_iter().map(|(path, _)| path).zip(sent).chain(idle) {
-            match result {
+        for (path, bps) in files {
+            match s.send_breakpoints(&path, &bps, None).await {
                Ok(states) => {
                    if first {
                        self.states.lock().insert(path.clone(), states);
@@ -997,72 +890,21 @@ impl DebugManager {

    /// Ends a session: `terminate` (when asked and supported) → `disconnect` → kill.
    pub(crate) async fn shutdown(&self, s: &Arc<Session>, terminate: bool) {
-        // java-debug runs the program itself and pipes its stdout over DAP. A `disconnect`
-        // ends that DAP session, so every line the program writes while shutting down is lost.
-        // Ask the program to exit ourselves and keep the adapter attached until it has drained
-        // the console (`terminated`), as IDEA does with the process it owns.
-        let pid = s.debuggee_pid.load(Ordering::Acquire);
-        let own_terminate = terminate && s.request == "launch" && pid > 0;
-        let graceful = terminate && s.request == "launch" && s.supports("supportsTerminateRequest");
        if !s.conn.is_closed() {
-            if graceful {
+            if terminate && s.request == "launch" && s.supports("supportsTerminateRequest") {
                let _ = s.conn.request_timeout("terminate", json!({ "restart": false }), SHUTDOWN_TIMEOUT).await;
            }
-            if !graceful && !own_terminate {
-                let _ = s
-                    .conn
-                    .request_timeout(
-                        "disconnect",
-                        json!({ "restart": false, "terminateDebuggee": s.request == "launch" }),
-                        SHUTDOWN_TIMEOUT,
-                    )
-                    .await;
-            }
-        }
-        if own_terminate && !graceful {
-            // Signal before anything else: waiting on a request the adapter may not answer
-            // would delay the shutdown the console is supposed to show.
-            crate::session::signal_debuggee(s, false);
-        }
-        if graceful {
-            // java-debug sends `terminated` only after it has drained the program's console
-            // (it waits up to 5 s for the output pump). Close on the process id alone and the
-            // last shutdown lines are dropped, so wait for that event here.
-            let deadline = std::time::Instant::now() + crate::session::DEBUGGEE_EXIT_WAIT;
-            while !s.terminated.load(Ordering::Acquire) && std::time::Instant::now() < deadline {
-                tokio::time::sleep(std::time::Duration::from_millis(50)).await;
-            }
-        }
-        // An adapter answers `disconnect` before the program it launched has exited, and that
-        // program keeps its port until it is gone. Reporting the session as terminated then
-        // lets Run start again into an occupied port, so wait for the program first — with the
-        // connection still open, so a second Stop can find the session and kill it.
-        crate::session::wait_for_debuggee(s, terminate).await;
-        if terminate && s.request == "launch" {
-            // The adapter reports `terminated` only after it has drained the program's console
-            // (java-debug waits up to 5 s for the pump): closing before that drops the last
-            // shutdown lines from the console.
-            let deadline = std::time::Instant::now() + std::time::Duration::from_secs(6);
-            while !s.terminated.load(Ordering::Acquire) && !s.conn.is_closed() && std::time::Instant::now() < deadline {
-                tokio::time::sleep(std::time::Duration::from_millis(50)).await;
-            }
-        }
-        if graceful && !s.conn.is_closed() {
            let _ = s
                .conn
                .request_timeout(
                    "disconnect",
-                    json!({ "restart": false, "terminateDebuggee": false }),
+                    json!({ "restart": false, "terminateDebuggee": s.request == "launch" }),
                    SHUTDOWN_TIMEOUT,
                )
                .await;
        }
        s.conn.close();
        self.session_closed(s);
-        if s.adapter == "delve" && s.spec.server_host.is_none() {
-            let cwd = s.spec.cwd.clone();
-            tokio::task::spawn_blocking(move || remove_delve_binaries(&cwd));
-        }
    }

    /// Breakpoints are kept per file even without a session and sent on start.
@@ -1093,7 +935,16 @@ impl DebugManager {
                Err(e) => tracing::debug!("setBreakpoints on session {} failed: {e}", s.id.0),
            }
        }
-        let states = result.unwrap_or_else(|| unsent(&breakpoints));
+        let states = result.unwrap_or_else(|| {
+            breakpoints
+                .iter()
+                .map(|b| BreakpointState {
+                    line: b.line,
+                    verified: false,
+                    message: (!b.enabled).then(|| "Disabled".to_owned()),
+                })
+                .collect()
+        });
        self.states.lock().insert(path, states.clone());
        Ok(states)
    }
@@ -1306,47 +1157,6 @@ 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?;
@@ -1360,29 +1170,6 @@ impl DebugManager {
        Ok(())
    }

-    /// Types `text` into the terminal the session's program runs in (see [`ide_core::event::DebugEvent::ProgramInput`]).
-    pub fn send_input(&self, s: DebugSessionId, text: &str) -> IdeResult<()> {
-        let session = self.session(s)?;
-        let mut program = session.program.lock();
-        let program = program
-            .as_mut()
-            .ok_or_else(|| IdeError::invalid("The program doesn't read input from the debug console"))?;
-        program.write(text).map_err(|e| IdeError::internal(format!("cannot write to the program: {e}")))
-    }
-
-    /// Flutter's DAP adapter: injects the changed sources into the running app.
-    /// Not part of the DAP standard; adapters that do not know the request reject it.
-    pub async fn hot_reload(&self, s: DebugSessionId) -> IdeResult<()> {
-        self.session(s)?.conn.request_timeout("hotReload", json!({ "reason": "manual" }), REQUEST_TIMEOUT).await?;
-        Ok(())
-    }
-
-    /// Flutter's DAP adapter: restarts the app without preserving state.
-    pub async fn hot_restart(&self, s: DebugSessionId) -> IdeResult<()> {
-        self.session(s)?.conn.request_timeout("hotRestart", json!({ "reason": "manual" }), REQUEST_TIMEOUT).await?;
-        Ok(())
-    }
-
    pub async fn step(&self, s: DebugSessionId, thread_id: i64, kind: StepKind) -> IdeResult<()> {
        let command = match kind {
            StepKind::Over => "next",
@@ -1421,26 +1208,13 @@ impl DebugManager {
    /// Sends empty breakpoint lists (line, function, data) to `session` until its next
    /// stop, when the stored ones are restored. `except` is left to the caller.
    async fn suspend_breakpoints(&self, session: &Arc<Session>, except: Option<&Path>) -> IdeResult<()> {
-        // While paused the adapter holds the stored lists: only files with something enabled change.
-        let files: Vec<PathBuf> = self
-            .breakpoints
-            .lock()
-            .iter()
-            .filter(|(path, bps)| Some(path.as_path()) != except && bps.iter().any(|b| b.enabled))
-            .map(|(path, _)| path.clone())
-            .collect();
-        let sent = join_all(files.iter().map(|path| session.send_breakpoints(path, &[], None))).await;
-        let mut failed = None;
-        for (path, result) in files.into_iter().zip(sent) {
-            match result {
-                Ok(_) => {
-                    session.pending_restore.lock().files.insert(path);
-                }
-                Err(e) => failed = failed.or(Some(e)),
+        let files: Vec<PathBuf> = self.breakpoints.lock().keys().cloned().collect();
+        for path in files {
+            if Some(path.as_path()) == except {
+                continue;
            }
-        }
-        if let Some(e) = failed {
-            return Err(e.into());
+            session.send_breakpoints(&path, &[], None).await?;
+            session.pending_restore.lock().files.insert(path);
        }
        if !self.function_breakpoints.lock().is_empty() && session.supports("supportsFunctionBreakpoints") {
            session.send_function_breakpoints(&[]).await?;
@@ -1456,11 +1230,9 @@ impl DebugManager {
    /// Re-sends what [`suspend_breakpoints`](Self::suspend_breakpoints) / run to cursor replaced.
    pub(crate) async fn restore_breakpoints(&self, session: &Arc<Session>) {
        let pending = std::mem::take(&mut *session.pending_restore.lock());
-        let files: Vec<(PathBuf, Vec<Breakpoint>)> =
-            pending.files.into_iter().map(|path| (path.clone(), self.stored_breakpoints(&path))).collect();
-        let sent = join_all(files.iter().map(|(path, bps)| session.send_breakpoints(path, bps, None))).await;
-        for ((path, _), result) in files.iter().zip(sent) {
-            if let Err(e) = result {
+        for path in pending.files {
+            let bps = self.stored_breakpoints(&path);
+            if let Err(e) = session.send_breakpoints(&path, &bps, None).await {
                tracing::debug!("restoring breakpoints of {} failed: {e}", path.display());
            }
        }
@@ -1627,40 +1399,10 @@ impl DebugManager {
        }
    }

-    /// Stops every debug session started from `root` or below — closing a project stops the
-    /// programs it launched even when the session's owner key does not name the window doing
-    /// the closing (window groups, auxiliary windows).
-    pub async fn stop_under(&self, root: &Path) {
-        let ids: Vec<DebugSessionId> =
-            self.live_sessions().into_iter().filter(|s| s.spec.cwd.starts_with(root)).map(|s| s.id).collect();
-        tracing::info!(root = %root.display(), sessions = ids.len(), "closing project: stopping debug sessions");
-        for id in ids {
-            if let Err(e) = self.stop(id).await {
-                tracing::debug!("debug session {id:?} did not stop: {e}");
-            }
-        }
-    }
-
-    /// Stops a session and its child sessions. A second Stop while the first one waits kills
-    /// the program instead of waiting for it — even after the adapter dropped the session.
+    /// Stops a session and its child sessions.
    pub async fn stop(&self, s: DebugSessionId) -> IdeResult<()> {
-        {
-            let in_flight = self.stopping.lock();
-            if let Some(session) = in_flight.get(&s) {
-                session.stop_force.store(true, Ordering::Release);
-                return Ok(());
-            }
-        }
        let session = self.session(s)?;
-        self.stopping.lock().insert(s, session.clone());
-        let result = self.stop_tree(session).await;
-        self.stopping.lock().remove(&s);
-        result
-    }
-
-    async fn stop_tree(&self, session: Arc<Session>) -> IdeResult<()> {
-        let children: Vec<Arc<Session>> =
-            self.live_sessions().into_iter().filter(|c| c.parent == Some(session.id)).collect();
+        let children: Vec<Arc<Session>> = self.live_sessions().into_iter().filter(|c| c.parent == Some(s)).collect();
        for child in children {
            self.shutdown(&child, true).await;
        }
@@ -13,7 +13,7 @@ use std::path::{Path, PathBuf};
 use std::process::Stdio;
 use std::sync::Arc;
 use std::sync::Weak;
-use std::sync::atomic::{AtomicBool, AtomicI64, Ordering};
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::time::Duration;
 use tokio::io::{AsyncRead, AsyncReadExt};
 use tokio::process::Child;
@@ -43,20 +43,10 @@ pub(crate) struct Session {
    pub adapter_process: Mutex<Option<Child>>,
    /// Processes started for `runInTerminal`.
    pub debuggees: Mutex<Vec<Child>>,
-    /// The terminal a `runInTerminal` program runs in: typed input goes to it.
-    pub program: Mutex<Option<ProgramTerminal>>,
    /// Set once `configurationDone` was sent; breakpoint updates go out live after that.
    pub configured: AtomicBool,
    pub initialized: watch::Sender<bool>,
    pub terminated: AtomicBool,
-    /// Set by a second Stop: the one waiting for the program kills it instead.
-    pub stop_force: AtomicBool,
-    /// `systemProcessId` from the adapter's `process` event: the program being debugged.
-    pub debuggee_pid: AtomicI64,
-    /// Pids signalled for the current stop: the reported pid and everything it started (an
-    /// adapter may report the launcher shell, whose child is the program).
-    #[cfg_attr(not(unix), allow(dead_code))]
-    pub stop_pids: parking_lot::Mutex<Vec<i32>>,
    /// Breakpoints replaced for run to cursor / force stepping, restored on the next stop.
    pub pending_restore: Mutex<PendingRestore>,
    /// Adapter breakpoint id → (file, index in the stored list).
@@ -100,13 +90,9 @@ impl Session {
            caps: Mutex::new(Value::Null),
            adapter_process: Mutex::new(child),
            debuggees: Mutex::new(Vec::new()),
-            program: Mutex::new(None),
            configured: AtomicBool::new(false),
            initialized: watch::channel(false).0,
            terminated: AtomicBool::new(false),
-            stop_force: AtomicBool::new(false),
-            debuggee_pid: AtomicI64::new(0),
-            stop_pids: parking_lot::Mutex::new(Vec::new()),
            pending_restore: Mutex::default(),
            breakpoint_ids: Mutex::new(HashMap::new()),
            resolved_paths: Mutex::new(HashMap::new()),
@@ -125,8 +111,8 @@ impl Session {
        if let Some(path) = self.kotlin_mirror.lock().as_ref().and_then(|m| m.adapter_path(path)) {
            return path;
        }
-        if self.adapter == "java-debug" || (cfg!(windows) && self.adapter == "netcoredbg") {
-            let native = windows_source_path(&path.to_string_lossy());
+        if self.adapter == "java-debug" {
+            let native = java_source_path(&path.to_string_lossy());
            self.resolved_paths.lock().insert(native.clone(), path.to_path_buf());
            return native;
        }
@@ -147,11 +133,7 @@ impl Session {
        if let Some(real) = self.kotlin_mirror.lock().as_ref().and_then(|m| m.client_path(Path::new(path))) {
            return Some(real);
        }
-        let key = if self.adapter == "java-debug" || (cfg!(windows) && self.adapter == "netcoredbg") {
-            windows_source_path(path)
-        } else {
-            PathBuf::from(path)
-        };
+        let key = if self.adapter == "java-debug" { java_source_path(path) } else { PathBuf::from(path) };
        self.resolved_paths.lock().get(&key).cloned().or_else(|| {
            (self.adapter == "java-debug" && is_windows_source_path(path))
                .then(|| PathBuf::from(path.replace('\\', "/")))
@@ -280,116 +262,11 @@ impl Session {
        for mut c in std::mem::take(&mut *self.debuggees.lock()) {
            let _ = c.start_kill();
        }
-        if let Some(mut program) = self.program.lock().take() {
-            let _ = program.child.kill();
-        }
    }
 }

-/// How long Stop waits for a launched program to exit before reporting the session ended.
-pub(crate) const DEBUGGEE_EXIT_WAIT: Duration = Duration::from_secs(10);
-
-/// The program and everything it started: an adapter may report the launcher shell, whose
-/// child is the debugged program, so stopping only the reported pid leaves the program alive.
-#[cfg(unix)]
-fn process_tree(pid: i32) -> Vec<i32> {
-    use std::collections::HashMap;
-    let Ok(out) = std::process::Command::new("ps").args(["-A", "-o", "pid=,ppid="]).output() else {
-        return vec![pid];
-    };
-    let mut children: HashMap<i32, Vec<i32>> = HashMap::new();
-    for line in String::from_utf8_lossy(&out.stdout).lines() {
-        let mut it = line.split_whitespace();
-        let (Some(p), Some(parent)) = (it.next(), it.next()) else { continue };
-        let (Ok(p), Ok(parent)) = (p.parse::<i32>(), parent.parse::<i32>()) else { continue };
-        children.entry(parent).or_default().push(p);
-    }
-    let mut tree = vec![pid];
-    let mut at = 0;
-    while at < tree.len() {
-        if let Some(kids) = children.get(&tree[at]) {
-            tree.extend(kids.iter().copied());
-        }
-        at += 1;
-    }
-    tree
-}
-
-/// Asks the program itself to exit (`force` = SIGKILL) without ending the adapter session:
-/// its output keeps flowing over DAP while it shuts down. The first call remembers the pid
-/// tree, because the reported pid may die before its program does.
-pub(crate) fn signal_debuggee(s: &Arc<Session>, force: bool) {
-    let pid = s.debuggee_pid.load(Ordering::Acquire);
-    if pid <= 0 {
-        return;
-    }
-    #[cfg(unix)]
-    {
-        let mut known = s.stop_pids.lock();
-        if known.is_empty() {
-            *known = process_tree(pid as i32);
-        }
-        let signal = if force { libc::SIGKILL } else { libc::SIGTERM };
-        // Children first: the shell that started the program would otherwise reparent it.
-        for p in known.iter().rev() {
-            // SAFETY: plain syscall on the processes this session started.
-            unsafe {
-                libc::kill(*p, signal);
-            }
-        }
-    }
-    #[cfg(windows)]
-    {
-        let mut cmd = std::process::Command::new("taskkill");
-        cmd.args(["/PID", &pid.to_string(), "/T"]);
-        if force {
-            cmd.arg("/F");
-        }
-        let _ = cmd.status();
-    }
-    #[cfg(not(any(unix, windows)))]
-    let _ = (pid, force);
-}
-
-/// Waits until the program a `launch` session started is gone; a second Stop kills it.
-pub(crate) async fn wait_for_debuggee(s: &Arc<Session>, terminate: bool) {
-    if !terminate || s.request != "launch" {
-        return;
-    }
-    let pid = s.debuggee_pid.load(Ordering::Acquire);
-    if pid <= 0 {
-        return;
-    }
-    tracing::info!(session = s.id.0, pid, "stop: waiting for the debugged program to exit");
-    #[cfg(unix)]
-    {
-        use std::time::Instant;
-        let targets = {
-            let known = s.stop_pids.lock();
-            if known.is_empty() { process_tree(pid as i32) } else { known.clone() }
-        };
-        let alive = || targets.iter().any(|p| unsafe { libc::kill(*p, 0) } == 0);
-        let deadline = Instant::now() + DEBUGGEE_EXIT_WAIT;
-        while alive() {
-            if s.stop_force.swap(false, Ordering::AcqRel) {
-                signal_debuggee(s, true);
-            }
-            if Instant::now() >= deadline {
-                // The program ignored the terminate: do not leave it running.
-                signal_debuggee(s, true);
-                break;
-            }
-            tokio::time::sleep(Duration::from_millis(50)).await;
-        }
-    }
-    #[cfg(not(unix))]
-    {
-        let _ = pid;
-    }
-}
-
-// java-debug and Windows netcoredbg need native separators for source lookup.
-// Keep DAP path mode, but normalize Windows drive and UNC paths.
+// java-debug treats a forward-slash drive path as a URI (scheme "C").
+// Keep DAP path mode, but use native Windows separators for Java source lookup.
 fn is_windows_source_path(path: &str) -> bool {
    let bytes = path.as_bytes();
    (bytes.len() >= 3 && bytes[0].is_ascii_alphabetic() && bytes[1] == b':' && matches!(bytes[2], b'/' | b'\\'))
@@ -397,7 +274,7 @@ fn is_windows_source_path(path: &str) -> bool {
        || path.starts_with(r"\\")
 }

-fn windows_source_path(path: &str) -> PathBuf {
+fn java_source_path(path: &str) -> PathBuf {
    if is_windows_source_path(path) { PathBuf::from(path.replace('/', r"\")) } else { PathBuf::from(path) }
 }

@@ -483,18 +360,8 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
                return;
            }
            let output = str_("output").unwrap_or_default();
-            if tracing::enabled!(tracing::Level::DEBUG) && mgr.stopping.lock().contains_key(&s.id) {
-                tracing::debug!(session = ?s.id, bytes = output.len(), "output during stop");
-            }
            s.emit(DebugEvent::Output { category, output });
        }
-        // The program the adapter started: Stop must wait for it, not for the adapter's reply.
-        // `process` is the DAP event; java-debug announces the same thing as `processid`.
-        "process" | "processid" => {
-            if let Some(pid) = int("systemProcessId").or_else(|| int("processId")).filter(|p| *p > 0) {
-                s.debuggee_pid.store(pid, Ordering::Release);
-            }
-        }
        "thread" => s.emit(DebugEvent::Thread {
            thread_id: int("threadId").unwrap_or(0),
            started: body.get("reason").and_then(Value::as_str) != Some("exited"),
@@ -513,18 +380,12 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
        }
        "exited" => {}
        "terminated" => {
-            let first = !s.terminated.swap(true, Ordering::AcqRel);
+            if !s.terminated.swap(true, Ordering::AcqRel) {
+                s.emit(DebugEvent::Terminated);
+            }
            let mgr = mgr.clone();
            let s = s.clone();
-            // Waiting here would stop reading the adapter: it keeps sending the program's last
-            // output while the program exits. Wait off the reader task, then report the end.
-            tokio::spawn(async move {
-                if first {
-                    wait_for_debuggee(&s, true).await;
-                    s.emit(DebugEvent::Terminated);
-                }
-                mgr.shutdown(&s, false).await;
-            });
+            tokio::spawn(async move { mgr.shutdown(&s, false).await });
        }
        "capabilities" => {
            if let Some(new) = body.get("capabilities").and_then(Value::as_object) {
@@ -586,25 +447,8 @@ fn on_reverse_request(mgr: &Arc<DebugManager>, s: &Arc<Session>, seq: i64, comma
    }
 }

-/// A `runInTerminal` program and the pseudo-terminal it runs in.
-pub(crate) struct ProgramTerminal {
-    writer: Box<dyn std::io::Write + Send>,
-    child: Box<dyn portable_pty::Child + Send + Sync>,
-    _master: Box<dyn portable_pty::MasterPty + Send>,
-}
-
-impl ProgramTerminal {
-    pub(crate) fn write(&mut self, text: &str) -> std::io::Result<()> {
-        self.writer.write_all(text.as_bytes())?;
-        self.writer.flush()
-    }
-}
-
-/// `runInTerminal`: starts the debuggee on a pseudo-terminal, as an IDE terminal would (CodeLLDB
-/// starts a launcher that gives the program its terminal, and the program reads input only from
-/// a terminal), forwards its output to the console, and keeps the terminal for typed input.
+/// `runInTerminal`: spawns the debuggee directly and forwards its output to the console.
 pub(crate) fn run_in_terminal(s: &Arc<Session>, args: &Value) -> Result<Value, String> {
-    use portable_pty::{CommandBuilder, PtySize, native_pty_system};
    let argv: Vec<String> = args
        .get("args")
        .and_then(Value::as_array)
@@ -613,25 +457,16 @@ pub(crate) fn run_in_terminal(s: &Arc<Session>, args: &Value) -> Result<Value, S
    let Some((program, rest)) = argv.split_first() else {
        return Err("runInTerminal without args".into());
    };
-    let pair = native_pty_system()
-        .openpty(PtySize { rows: 24, cols: 200, pixel_width: 0, pixel_height: 0 })
-        .map_err(|e| format!("cannot open a terminal for {program}: {e}"))?;
-    let mut cmd = CommandBuilder::new(program);
-    // CodeLLDB's launcher clears the terminal first; the console keeps the session's earlier output.
-    cmd.args(rest.iter().filter(|a| *a != "--clear-screen"));
-    for (k, v) in ide_core::process::host_env_fixes() {
-        match v {
-            Some(v) => cmd.env(k, v),
-            None => cmd.env_remove(k),
-        }
-    }
-    for (k, v) in ide_core::process::shell_env() {
-        cmd.env(k, v);
-    }
-    cmd.env("TERM", "xterm-256color");
-    match args.get("cwd").and_then(Value::as_str).filter(|c| !c.is_empty()) {
-        Some(cwd) => cmd.cwd(cwd),
-        None => cmd.cwd(&s.spec.cwd),
+    let mut cmd = tokio::process::Command::new(program);
+    ide_core::process::prepare(cmd.as_std_mut());
+    cmd.args(rest)
+        .envs(ide_core::process::shell_env())
+        .stdin(Stdio::null())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .kill_on_drop(true);
+    if let Some(cwd) = args.get("cwd").and_then(Value::as_str).filter(|c| !c.is_empty()) {
+        cmd.current_dir(cwd);
    }
    if let Some(env) = args.get("env").and_then(Value::as_object) {
        for (k, v) in env {
@@ -641,53 +476,18 @@ pub(crate) fn run_in_terminal(s: &Arc<Session>, args: &Value) -> Result<Value, S
            };
        }
    }
-    let child = pair.slave.spawn_command(cmd).map_err(|e| format!("failed to start {program}: {e}"))?;
-    drop(pair.slave);
-    let reader = pair.master.try_clone_reader().map_err(|e| format!("terminal of {program}: {e}"))?;
-    let writer = pair.master.take_writer().map_err(|e| format!("terminal of {program}: {e}"))?;
-    let pid = child.process_id();
-    forward_terminal_output(s, reader);
-    if let Some(mut previous) = s.program.lock().replace(ProgramTerminal { writer, child, _master: pair.master }) {
-        let _ = previous.child.kill();
+    let mut child = cmd.spawn().map_err(|e| format!("failed to start {program}: {e}"))?;
+    let pid = child.id();
+    if let Some(out) = child.stdout.take() {
+        forward_output(s, out, "stdout");
    }
-    s.owner.sink.emit(IdeEvent::Debug { session: s.id, event: DebugEvent::ProgramInput });
+    if let Some(err) = child.stderr.take() {
+        forward_output(s, err, "stderr");
+    }
+    s.debuggees.lock().push(child);
    Ok(json!({ "processId": pid }))
 }

-/// The program's terminal output, as stdout lines (`\r\n` as `\n`; colours are kept).
-fn forward_terminal_output(s: &Session, mut reader: Box<dyn std::io::Read + Send>) {
-    let session = s.id;
-    let sink = s.owner.sink.clone();
-    let _ = std::thread::Builder::new().name(format!("openidea-debuggee-{}", session.0)).spawn(move || {
-        let mut buf = vec![0u8; 8192];
-        let mut pending: Vec<u8> = Vec::new();
-        loop {
-            match reader.read(&mut buf) {
-                Ok(0) | Err(_) => break,
-                Ok(n) => pending.extend_from_slice(&buf[..n]),
-            }
-            // Keep incomplete UTF-8 sequences, and a `\r` that may start a `\r\n`, for the next chunk.
-            let mut valid = match std::str::from_utf8(&pending) {
-                Ok(_) => pending.len(),
-                Err(e) if e.error_len().is_none() => e.valid_up_to(),
-                Err(_) => pending.len(),
-            };
-            if valid > 0 && pending[valid - 1] == b'\r' {
-                valid -= 1;
-            }
-            let output = String::from_utf8_lossy(&pending[..valid]).replace("\r\n", "\n");
-            pending.drain(..valid);
-            if !output.is_empty() {
-                sink.emit(IdeEvent::Debug { session, event: DebugEvent::Output { category: "stdout".into(), output } });
-            }
-        }
-        if !pending.is_empty() {
-            let output = String::from_utf8_lossy(&pending).replace("\r\n", "\n");
-            sink.emit(IdeEvent::Debug { session, event: DebugEvent::Output { category: "stdout".into(), output } });
-        }
-    });
-}
-
 fn forward_output<R: AsyncRead + Unpin + Send + 'static>(s: &Session, mut stream: R, category: &'static str) {
    let session = s.id;
    let sink = s.owner.sink.clone();
@@ -5,16 +5,11 @@ use crate::adapter::{AdapterIo, LaunchFuture};
 use ide_core::IdeEvent;
 use ide_core::event::DebugEvent;
 use ide_jsonrpc::framing;
-#[cfg(unix)]
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::time::Duration;
-#[cfg(unix)]
-use std::time::Instant;
 use tokio::io::{AsyncRead, AsyncWrite, AsyncWriteExt, BufReader};

 type Log = Arc<Mutex<Vec<Value>>>;

-#[derive(Clone)]
+#[derive(Clone, Default)]
 struct Script {
    /// Send a `runInTerminal` reverse request when `launch` arrives.
    run_in_terminal: Option<Vec<String>>,
@@ -22,33 +17,6 @@ struct Script {
    start_debugging: bool,
    ignore_configuration_done: bool,
    source_path: Option<String>,
-    /// Report this process id in the adapter's `process` event (the program being debugged).
-    debuggee_pid: Option<u32>,
-    /// java-debug's spelling of the same event.
-    java_process_id: bool,
-    /// Send one more output event right after the `terminated` event (a program still logging
-    /// while it shuts down).
-    output_after_terminate: bool,
-    /// Advertise `supportsTerminateRequest` (java-debug does not, so Stop signals the program).
-    supports_terminate: bool,
-    /// Answer `setBreakpoints` only once this many are waiting (a client that waits for each never gets one).
-    hold_set_breakpoints: usize,
-}
-
-impl Default for Script {
-    fn default() -> Self {
-        Self {
-            run_in_terminal: None,
-            start_debugging: false,
-            ignore_configuration_done: false,
-            source_path: None,
-            debuggee_pid: None,
-            java_process_id: false,
-            output_after_terminate: false,
-            supports_terminate: true,
-            hold_set_breakpoints: 0,
-        }
-    }
 }

 struct FakeLauncher {
@@ -81,7 +49,6 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
    let mut r = BufReader::new(r);
    let mut seq = 1000;
    let mut pending_launch: Option<i64> = None;
-    let mut held: Vec<Value> = Vec::new();
    macro_rules! send {
        ($v:expr) => {{
            let mut v: Value = $v;
@@ -106,8 +73,7 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
                msg,
                json!({
                    "supportsConfigurationDoneRequest": true,
-                    "supportsCompletionsRequest": true,
-                    "supportsTerminateRequest": script.supports_terminate,
+                    "supportsTerminateRequest": true,
                    "supportsSetVariable": true,
                    "supportsFunctionBreakpoints": true,
                    "supportsDataBreakpoints": true,
@@ -134,20 +100,14 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
                send!(json!({"type": "event", "event": "initialized"}));
            }
            "setBreakpoints" => {
-                held.push(msg);
-                if held.len() < script.hold_set_breakpoints {
-                    continue;
-                }
-                for msg in std::mem::take(&mut held) {
-                    let bps: Vec<Value> = msg["arguments"]["breakpoints"]
-                        .as_array()
-                        .unwrap()
-                        .iter()
-                        .enumerate()
-                        .map(|(i, b)| json!({"id": i + 1, "verified": true, "line": b["line"]}))
-                        .collect();
-                    ok!(msg, json!({"breakpoints": bps}));
-                }
+                let bps: Vec<Value> = msg["arguments"]["breakpoints"]
+                    .as_array()
+                    .unwrap()
+                    .iter()
+                    .enumerate()
+                    .map(|(i, b)| json!({"id": i + 1, "verified": true, "line": b["line"]}))
+                    .collect();
+                ok!(msg, json!({"breakpoints": bps}));
            }
            "setExceptionBreakpoints" => ok!(msg, json!({})),
            "setFunctionBreakpoints" | "setDataBreakpoints" => {
@@ -185,14 +145,6 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
                if let Some(l) = pending_launch.take() {
                    send!(json!({"type": "response", "request_seq": l, "command": "launch", "success": true}));
                }
-                if let Some(pid) = script.debuggee_pid {
-                    let event = if script.java_process_id {
-                        json!({"type": "event", "event": "processid", "body": {"processId": pid, "shellProcessId": pid}})
-                    } else {
-                        json!({"type": "event", "event": "process", "body": {"name": "prog", "systemProcessId": pid}})
-                    };
-                    send!(event);
-                }
                send!(json!({"type": "event", "event": "output", "body": {"category": "stdout", "output": "hello\n"}}));
                send!(
                    json!({"type": "event", "event": "stopped", "body": {"reason": "breakpoint", "threadId": 1, "allThreadsStopped": true}})
@@ -220,14 +172,6 @@ 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}}));
@@ -246,11 +190,6 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
            "terminate" => {
                ok!(msg, Value::Null);
                send!(json!({"type": "event", "event": "terminated"}));
-                if script.output_after_terminate {
-                    send!(
-                        json!({"type": "event", "event": "output", "body": {"category": "stdout", "output": "late\n"}})
-                    );
-                }
            }
            "disconnect" => {
                ok!(msg, Value::Null);
@@ -429,14 +368,6 @@ 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();
@@ -520,40 +451,6 @@ async fn run_in_terminal_spawns_debuggee() {
    assert!(response["body"]["processId"].as_u64().unwrap() > 0);
 }

-#[cfg(unix)]
-#[tokio::test]
-async fn run_in_terminal_program_reads_typed_input() {
-    let h = harness(Script {
-        // CodeLLDB's launcher asks to clear the terminal; the console keeps its output.
-        run_in_terminal: Some(vec![
-            "sh".into(),
-            "-c".into(),
-            "[ -t 0 ] && echo 'name?' && read name && echo \"hello $name\"".into(),
-            "--clear-screen".into(),
-        ]),
-        ..Script::default()
-    });
-    let session = h.start(config()).await.unwrap();
-    h.wait_event(|e| matches!(e, DebugEvent::ProgramInput)).await;
-    h.wait_event(|e| matches!(e, DebugEvent::Output { output, .. } if output.contains("name?"))).await;
-    h.manager.send_input(session, "Bob\n").unwrap();
-    h.wait_event(|e| matches!(e, DebugEvent::Output { output, .. } if output.contains("hello Bob"))).await;
-    let output: String = h
-        .events
-        .lock()
-        .iter()
-        .filter_map(|e| match e {
-            IdeEvent::Debug { event: DebugEvent::Output { category, output }, .. } if category == "stdout" => {
-                Some(output.clone())
-            }
-            _ => None,
-        })
-        .collect();
-    assert!(!output.contains('\r'), "{output:?}");
-    h.manager.stop(session).await.unwrap();
-    assert!(h.manager.send_input(session, "x\n").is_err());
-}
-
 #[test]
 fn launch_arguments_merge_and_defaults() {
    let mut c = config();
@@ -784,37 +681,6 @@ 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]
@@ -973,7 +839,6 @@ async fn force_stepping_suspends_breakpoints_until_the_next_stop() {
    let b = PathBuf::from("/p/b.py");
    h.manager.set_breakpoints(a.clone(), vec![bp(1)]).await.unwrap();
    h.manager.set_breakpoints(b.clone(), vec![bp(3)]).await.unwrap();
-    h.manager.set_breakpoints(PathBuf::from("/p/off.py"), vec![Breakpoint { enabled: false, ..bp(5) }]).await.unwrap();
    h.manager.set_function_breakpoints(vec![function_bp("run", true)]).await.unwrap();
    let id = h.start(config()).await.unwrap();
    h.wait_event(|e| matches!(e, DebugEvent::Stopped { .. })).await;
@@ -1002,24 +867,6 @@ async fn force_stepping_suspends_breakpoints_until_the_next_stop() {
    h.manager.run_to(id, 1, a.clone(), 9, true).await.unwrap();
    assert_eq!(sent_for("/p/a.py").last().unwrap(), &json!([{"line": 10}]));
    assert_eq!(sent_for("/p/b.py").last().unwrap(), &json!([]));
-    assert!(sent_for("/p/off.py").is_empty(), "nothing enabled there, nothing to suspend or restore");
-}
-
-#[tokio::test]
-async fn startup_sends_every_file_at_once_and_skips_files_with_nothing_enabled() {
-    let h = harness(Script { hold_set_breakpoints: 2, ..Script::default() });
-    h.manager.set_breakpoints(PathBuf::from("/p/a.py"), vec![bp(1)]).await.unwrap();
-    h.manager.set_breakpoints(PathBuf::from("/p/b.py"), vec![bp(3)]).await.unwrap();
-    let off = PathBuf::from("/p/off.py");
-    h.manager.set_breakpoints(off.clone(), vec![Breakpoint { enabled: false, ..bp(5) }]).await.unwrap();
-    // Waiting for each answer before the next request would stall until the request timeout.
-    tokio::time::timeout(Duration::from_secs(5), h.start(config())).await.expect("requests pipelined").unwrap();
-    let paths: Vec<Value> = requests(&h, "setBreakpoints").into_iter().map(|r| r["source"]["path"].clone()).collect();
-    assert_eq!(paths, [json!("/p/a.py"), json!("/p/b.py")]);
-    assert_eq!(
-        h.manager.breakpoint_states(&off),
-        [BreakpointState { line: 5, verified: false, message: Some("Disabled".into()) }]
-    );
 }

 #[tokio::test]
@@ -1059,7 +906,6 @@ 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 {
@@ -1246,23 +1092,6 @@ async fn kotlin_official_release_ten_no_delay_runs() {
    }
 }

-#[cfg(windows)]
-#[tokio::test]
-async fn netcoredbg_windows_source_paths_round_trip() {
-    let client = "D:/work/LoginController.cs";
-    let native = r"D:\work\LoginController.cs";
-    let h = harness(Script { source_path: Some(native.into()), ..Script::default() });
-    let path = PathBuf::from(client);
-    h.manager.set_breakpoints(path.clone(), vec![bp(25)]).await.unwrap();
-    let mut cfg = config();
-    cfg.adapter = "netcoredbg".into();
-    let id = h.start(cfg).await.unwrap();
-    assert_eq!(h.request("setBreakpoints")["arguments"]["source"]["path"], native);
-    let frames = h.manager.stack_trace(id, 1).await.unwrap();
-    assert_eq!(frames[0].path.as_deref(), Some(path.as_path()));
-    h.manager.stop(id).await.unwrap();
-}
-
 #[tokio::test]
 async fn java_windows_source_paths_for_launch_and_attach() {
    for request in ["launch", "attach"] {
@@ -1374,237 +1203,3 @@ async fn a_plugin_language_runs_its_debug_adapter_from_the_approved_program() {
    assert_eq!(err.kind, ide_core::error::ErrorKind::PermissionDenied, "{}", err.message);
    let _ = std::fs::remove_dir_all(&dir);
 }
-
-#[test]
-fn flutter_projects_are_found_from_the_program_or_the_working_directory() {
-    let root = std::env::temp_dir().join(format!("openidea-flutter-{}", std::process::id()));
-    let app = root.join("app");
-    let tool = root.join("tool");
-    std::fs::create_dir_all(app.join("lib")).unwrap();
-    std::fs::create_dir_all(tool.join("bin")).unwrap();
-    std::fs::write(app.join("pubspec.yaml"), "name: app\ndependencies:\n  flutter:\n    sdk: flutter\n").unwrap();
-    std::fs::write(tool.join("pubspec.yaml"), "name: tool\ndependencies:\n  args: ^2.0.0\n").unwrap();
-    assert!(is_flutter_project(&app, None));
-    assert!(is_flutter_project(&root, Some(&app.join("lib/main.dart"))));
-    assert!(!is_flutter_project(&tool, Some(&tool.join("bin/main.dart"))));
-    assert!(!is_flutter_project(&root, None));
-    std::fs::remove_dir_all(&root).unwrap();
-}
-
-#[cfg(unix)]
-#[tokio::test]
-async fn stop_waits_for_the_launched_program_to_exit() {
-    // The adapter answers `disconnect` at once; the program it started is still alive and
-    // holds its port for a while. Stop must not report the session as over before it exits.
-    // Reaped by a waiting thread: a zombie still "exists" for `kill(pid, 0)`, unlike the
-    // program an adapter starts and reaps.
-    // Ignores SIGTERM: Stop must wait for the program, not assume the signal ended it.
-    let mut child = std::process::Command::new("python3")
-        .args(["-c", "import signal,time; signal.signal(signal.SIGTERM, signal.SIG_IGN); time.sleep(1)"])
-        .spawn()
-        .unwrap();
-    let pid = child.id();
-    std::thread::spawn(move || {
-        let _ = child.wait();
-    });
-    let h = harness(Script { debuggee_pid: Some(pid), ..Default::default() });
-    let id = h.start(config()).await.unwrap();
-    h.wait_event(|e| matches!(e, DebugEvent::Initialized)).await;
-    for _ in 0..100 {
-        if h.manager.session(id).map(|s| s.debuggee_pid.load(Ordering::Acquire)).ok() == Some(i64::from(pid)) {
-            break;
-        }
-        tokio::time::sleep(Duration::from_millis(10)).await;
-    }
-    tokio::time::sleep(Duration::from_millis(200)).await; // let the program install its trap
-    let started = Instant::now();
-    h.manager.stop(id).await.unwrap();
-    let elapsed = started.elapsed();
-    assert!(elapsed >= Duration::from_millis(800), "stop returned after {elapsed:?}, before the program exited");
-    assert!(elapsed < Duration::from_secs(5), "stop waited {elapsed:?} for a program that ended after a second");
-    h.wait_event(|e| matches!(e, DebugEvent::Terminated)).await;
-}
-
-#[cfg(unix)]
-#[tokio::test]
-async fn a_second_stop_kills_the_program_instead_of_waiting() {
-    let mut child = std::process::Command::new("python3")
-        .args(["-c", "import signal,time; signal.signal(signal.SIGTERM, signal.SIG_IGN); time.sleep(30)"])
-        .spawn()
-        .unwrap();
-    let pid = child.id();
-    let exited = Arc::new(AtomicBool::new(false));
-    {
-        let exited = exited.clone();
-        std::thread::spawn(move || {
-            let _ = child.wait();
-            exited.store(true, Ordering::Release);
-        });
-    }
-    let h = harness(Script { debuggee_pid: Some(pid), ..Default::default() });
-    let id = h.start(config()).await.unwrap();
-    h.wait_event(|e| matches!(e, DebugEvent::Initialized)).await;
-    for _ in 0..100 {
-        if h.manager.session(id).map(|s| s.debuggee_pid.load(Ordering::Acquire)).ok() == Some(i64::from(pid)) {
-            break;
-        }
-        tokio::time::sleep(Duration::from_millis(10)).await;
-    }
-    tokio::time::sleep(Duration::from_millis(400)).await;
-    let first = tokio::spawn({
-        let manager = h.manager.clone();
-        async move { manager.stop(id).await }
-    });
-    tokio::time::sleep(Duration::from_millis(300)).await;
-    assert!(!exited.load(Ordering::Acquire), "the program is still alive while the first Stop waits");
-    let started = Instant::now();
-    h.manager.stop(id).await.unwrap();
-    let first_result = tokio::time::timeout(Duration::from_secs(5), first).await.expect("the first Stop returns");
-    first_result.unwrap().unwrap();
-    assert!(started.elapsed() < Duration::from_secs(2), "a second Stop does not wait out the program");
-    for _ in 0..100 {
-        if exited.load(Ordering::Acquire) {
-            break;
-        }
-        tokio::time::sleep(Duration::from_millis(10)).await;
-    }
-    assert!(exited.load(Ordering::Acquire), "the second Stop killed the program");
-}
-
-#[cfg(unix)]
-#[tokio::test]
-async fn stop_waits_for_the_program_when_the_adapter_uses_javas_processid_event() {
-    // Ignores SIGTERM: Stop must wait for the program, not assume the signal ended it.
-    let mut child = std::process::Command::new("python3")
-        .args(["-c", "import signal,time; signal.signal(signal.SIGTERM, signal.SIG_IGN); time.sleep(1)"])
-        .spawn()
-        .unwrap();
-    let pid = child.id();
-    std::thread::spawn(move || {
-        let _ = child.wait();
-    });
-    let h = harness(Script { debuggee_pid: Some(pid), java_process_id: true, ..Default::default() });
-    let id = h.start(config()).await.unwrap();
-    h.wait_event(|e| matches!(e, DebugEvent::Initialized)).await;
-    for _ in 0..100 {
-        if h.manager.session(id).map(|s| s.debuggee_pid.load(Ordering::Acquire)).ok() == Some(i64::from(pid)) {
-            break;
-        }
-        tokio::time::sleep(Duration::from_millis(10)).await;
-    }
-    tokio::time::sleep(Duration::from_millis(200)).await;
-    let started = Instant::now();
-    h.manager.stop(id).await.unwrap();
-    assert!(
-        started.elapsed() >= Duration::from_millis(800),
-        "stop returned after {:?}, before the program exited",
-        started.elapsed()
-    );
-}
-
-#[cfg(unix)]
-#[tokio::test]
-async fn output_keeps_arriving_while_a_stopped_program_is_exiting() {
-    // Ignores SIGTERM: Stop must wait for the program, not assume the signal ended it.
-    let mut child = std::process::Command::new("python3")
-        .args(["-c", "import signal,time; signal.signal(signal.SIGTERM, signal.SIG_IGN); time.sleep(1)"])
-        .spawn()
-        .unwrap();
-    let pid = child.id();
-    std::thread::spawn(move || {
-        let _ = child.wait();
-    });
-    let h = harness(Script { debuggee_pid: Some(pid), output_after_terminate: true, ..Default::default() });
-    let id = h.start(config()).await.unwrap();
-    h.wait_event(|e| matches!(e, DebugEvent::Initialized)).await;
-    for _ in 0..100 {
-        if h.manager.session(id).map(|s| s.debuggee_pid.load(Ordering::Acquire)).ok() == Some(i64::from(pid)) {
-            break;
-        }
-        tokio::time::sleep(Duration::from_millis(10)).await;
-    }
-    let started = Instant::now();
-    let stop = tokio::spawn({
-        let manager = h.manager.clone();
-        async move { manager.stop(id).await }
-    });
-    // The last line must reach the console while Stop still waits for the program.
-    h.wait_event(|e| matches!(e, DebugEvent::Output { output, .. } if output == "late\n")).await;
-    assert!(started.elapsed() < Duration::from_millis(800), "output arrived only after the program was gone");
-    stop.await.unwrap().unwrap();
-}
-
-#[tokio::test]
-async fn closing_a_project_stops_the_debug_sessions_it_started() {
-    let h = harness(Script::default());
-    let id = h.start(config()).await.unwrap();
-    h.wait_event(|e| matches!(e, DebugEvent::Initialized)).await;
-    // The session's cwd is /p, whatever key it was started under.
-    h.manager.stop_under(Path::new("/p")).await;
-    h.wait_event(|e| matches!(e, DebugEvent::Terminated)).await;
-    assert!(h.manager.sessions(None).is_empty(), "session {id:?} is gone");
-}
-
-#[cfg(unix)]
-#[tokio::test]
-async fn stop_kills_the_program_started_by_the_reported_launcher() {
-    use std::io::BufRead;
-    // java-debug reports the launcher shell; the JVM is its child. Stopping only the reported
-    // pid orphans the program, which keeps running (and keeps its ports).
-    let mut launcher = std::process::Command::new("sh")
-        .args(["-c", "python3 -c 'import time; time.sleep(30)' & echo $!; wait"])
-        .stdout(std::process::Stdio::piped())
-        .spawn()
-        .unwrap();
-    let launcher_pid = launcher.id();
-    let mut line = String::new();
-    std::io::BufReader::new(launcher.stdout.take().unwrap()).read_line(&mut line).unwrap();
-    let program: i32 = line.trim().parse().expect("child pid");
-    // Reap the launcher: a zombie still "exists" for `kill(pid, 0)`, unlike the shell jdtls reaps.
-    std::thread::spawn(move || {
-        let _ = launcher.wait();
-    });
-
-    let h = harness(Script {
-        debuggee_pid: Some(launcher_pid),
-        supports_terminate: false, // java-debug does not advertise it
-        ..Default::default()
-    });
-    let id = h.start(config()).await.unwrap();
-    h.wait_event(|e| matches!(e, DebugEvent::Initialized)).await;
-    for _ in 0..100 {
-        if h.manager.session(id).map(|s| s.debuggee_pid.load(Ordering::Acquire)).ok() == Some(i64::from(launcher_pid)) {
-            break;
-        }
-        tokio::time::sleep(Duration::from_millis(10)).await;
-    }
-    h.manager.stop(id).await.unwrap();
-    let deadline = Instant::now() + Duration::from_secs(5);
-    while unsafe { libc::kill(program, 0) } == 0 {
-        assert!(Instant::now() < deadline, "the program the launcher started survived stop");
-        tokio::time::sleep(Duration::from_millis(50)).await;
-    }
-}
-
-#[test]
-fn delve_leftovers_are_removed_without_touching_other_files() {
-    let dir = std::env::temp_dir().join(format!("openidea-delve-bin-{}", std::process::id()));
-    std::fs::create_dir_all(&dir).unwrap();
-    for name in ["__debug_bin", "__debug_bin.exe", "__debug_bin.exe3323301925"] {
-        std::fs::write(dir.join(name), b"bin").unwrap();
-    }
-    // Lookalikes that are not Delve's own binaries stay: sources, a future
-    // in-progress build, and a directory that happens to share the name.
-    for name in ["__debug_bin.go", "__debug_bin.go.exe", "main.go"] {
-        std::fs::write(dir.join(name), b"keep").unwrap();
-    }
-    std::fs::create_dir(dir.join("__debug_bin.dir")).unwrap();
-    remove_delve_binaries(&dir);
-    for name in ["__debug_bin", "__debug_bin.exe", "__debug_bin.exe3323301925"] {
-        assert!(!dir.join(name).exists(), "{name} should be gone");
-    }
-    for name in ["__debug_bin.go", "__debug_bin.go.exe", "main.go", "__debug_bin.dir"] {
-        assert!(dir.join(name).exists(), "{name} should stay");
-    }
-    std::fs::remove_dir_all(&dir).unwrap();
-}
@@ -1,140 +0,0 @@
-//! Drives php-debug (vscode-php-debug) the way a PHP Remote Debug (Xdebug)
-//! configuration does: a launch without a program makes it listen, and every PHP
-//! run that Xdebug connects stops at the breakpoint set in the local copy of the
-//! file, through `pathMappings`, until the session is stopped. A second listener on
-//! the same port fails to start and names the port.
-//!
-//! Ignored by default (needs PHP with Xdebug 3, Node.js and php-debug). Run with
-//! `PHP_DEBUG_ADAPTER=<php-debug-adapter> cargo test -p ide-dap --test php_debug -- --ignored --nocapture`
-//! (`PHP_BIN` picks the PHP executable, default `php`).
-
-use ide_core::event::DebugEvent;
-use ide_core::ipc_path::to_ipc;
-use ide_core::{IdeEvent, SharedSink};
-use ide_dap::*;
-use ide_language::LanguageRegistry;
-use parking_lot::Mutex;
-use std::collections::BTreeMap;
-use std::path::{Path, PathBuf};
-use std::sync::Arc;
-use std::time::{Duration, Instant};
-
-const SCRIPT: &str = "<?php\n$greeting = \"hello\";\n$n = 40 + 2;\necho \"$greeting $n\\n\";\n";
-/// 0-based line of `$n = 40 + 2;`.
-const BREAK_LINE: u32 = 2;
-
-async fn wait_for(events: &Mutex<Vec<IdeEvent>>, timeout: Duration, pred: impl Fn(&DebugEvent) -> bool) -> DebugEvent {
-    let start = Instant::now();
-    loop {
-        if let Some(e) = events.lock().iter().find_map(|e| match e {
-            IdeEvent::Debug { event, .. } if pred(event) => Some(event.clone()),
-            _ => None,
-        }) {
-            return e;
-        }
-        assert!(start.elapsed() < timeout, "timed out; events: {:#?}", events.lock());
-        tokio::time::sleep(Duration::from_millis(50)).await;
-    }
-}
-
-fn listen_config(port: u16, served: &Path, local: &Path) -> LaunchConfig {
-    // As remote.ts builds it for Remote root = `served`, Local root = `local`.
-    let mapping = serde_json::Map::from_iter([(to_ipc(served), to_ipc(local).into())]);
-    LaunchConfig {
-        name: "PHP Remote".into(),
-        adapter: "php-debug".into(),
-        request: "launch".into(),
-        program: None,
-        args: vec![],
-        cwd: Some(local.to_path_buf().into()),
-        env: BTreeMap::new(),
-        extra_json: Some(serde_json::json!({ "port": port, "pathMappings": mapping }).to_string()),
-    }
-}
-
-#[tokio::test(flavor = "multi_thread")]
-#[ignore]
-async fn listens_for_xdebug_until_stopped_with_path_mappings() {
-    let Ok(adapter) = std::env::var("PHP_DEBUG_ADAPTER") else {
-        eprintln!("PHP_DEBUG_ADAPTER not set; skipping");
-        return;
-    };
-    let php = std::env::var("PHP_BIN").unwrap_or_else(|_| "php".into());
-    let dir = tempfile::tempdir().unwrap();
-    // The project here, and the copy PHP runs from (a container's /var/www/html).
-    let (local, served) = (dir.path().join("local"), dir.path().join("served"));
-    for d in [&local, &served] {
-        std::fs::create_dir_all(d).unwrap();
-        std::fs::write(d.join("index.php"), SCRIPT).unwrap();
-    }
-    // Resolved like the project root the UI sends (`/private/var` on macOS, no `\\?\` on Windows).
-    let resolved = |p: &Path| PathBuf::from(to_ipc(&std::fs::canonicalize(p).unwrap()));
-    let (local, served) = (resolved(&local), resolved(&served));
-    let port = std::net::TcpListener::bind(("127.0.0.1", 0)).unwrap().local_addr().unwrap().port();
-
-    let manager = DebugManager::new(Arc::new(LanguageRegistry::load(None).unwrap()));
-    let events: Arc<Mutex<Vec<IdeEvent>>> = Arc::default();
-    let sink: SharedSink = {
-        let events = events.clone();
-        Arc::new(move |e: IdeEvent| events.lock().push(e))
-    };
-    let local_script = local.join("index.php");
-    manager
-        .set_breakpoints(
-            local_script.clone(),
-            vec![Breakpoint {
-                line: BREAK_LINE,
-                condition: None,
-                hit_condition: None,
-                log_message: None,
-                enabled: true,
-            }],
-        )
-        .await
-        .unwrap();
-    let id = manager
-        .start_with(listen_config(port, &served, &local), SessionOwner::new("main", sink.clone()), |_| {
-            Some(adapter.clone())
-        })
-        .await
-        .unwrap_or_else(|e| panic!("start: {e:?}"));
-
-    // Requests in a row each stop; the session keeps listening between them.
-    for request in 1..=2 {
-        events.lock().clear();
-        let run = std::process::Command::new(&php)
-            .args([
-                "-dxdebug.mode=debug",
-                "-dxdebug.start_with_request=yes",
-                "-dxdebug.client_host=127.0.0.1",
-                &format!("-dxdebug.client_port={port}"),
-                "index.php",
-            ])
-            .current_dir(&served)
-            .stdout(std::process::Stdio::piped())
-            .spawn()
-            .unwrap();
-        let stopped = wait_for(&events, Duration::from_secs(30), |e| matches!(e, DebugEvent::Stopped { .. })).await;
-        let DebugEvent::Stopped { thread_id, .. } = stopped else { unreachable!() };
-        let frames = manager.stack_trace(id, thread_id).await.unwrap();
-        assert_eq!(frames[0].line, BREAK_LINE, "request {request}");
-        let top = frames[0].path.as_deref().and_then(|p| p.canonicalize().ok());
-        assert_eq!(top, local_script.canonicalize().ok(), "request {request}");
-        manager.resume(id, thread_id).await.unwrap();
-        wait_for(&events, Duration::from_secs(30), |e| matches!(e, DebugEvent::Thread { started: false, .. })).await;
-        let out = run.wait_with_output().unwrap();
-        assert_eq!(String::from_utf8_lossy(&out.stdout), "hello 42\n", "request {request}");
-        assert!(manager.sessions(None).iter().any(|s| s.id == id), "still listening after request {request}");
-    }
-
-    // Another listener on the port (another IDE): the start fails and says why.
-    let err = manager
-        .start_with(listen_config(port, &served, &local), SessionOwner::new("main", sink), |_| Some(adapter.clone()))
-        .await
-        .expect_err("a second listener on the same port");
-    assert!(err.message.contains("EADDRINUSE") && err.message.ends_with(&format!(":{port}")), "{err:?}");
-    assert_eq!(manager.sessions(None).len(), 1);
-
-    manager.stop(id).await.unwrap();
-    assert!(manager.sessions(None).is_empty());
-}
@@ -8,7 +8,7 @@ license.workspace = true
 [dependencies]
 ide-core.workspace = true
 serde.workspace = true
-serde_json = { workspace = true, features = ["raw_value"] }
+serde_json.workspace = true
 specta.workspace = true
 toml.workspace = true
 tokio.workspace = true
@@ -17,17 +17,11 @@ parking_lot.workspace = true
 futures.workspace = true
 sqlx.workspace = true
 tiberius.workspace = true
-oracle.workspace = true
 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"] }
 tempfile.workspace = true
-ide-ssh = { workspace = true, features = ["testing"] }
@@ -1,889 +0,0 @@
-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"))
-    }
-
-    /// `max_rows`: the rows the server may send (the skipped ones included).
-    fn request(&self, client: &Client, query_id: &str, max_rows: usize, initialized: bool) -> RequestBuilder {
-        let mut request = client
-            .post(self.0.endpoint.clone())
-            .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> {
-        self.execute_from(sql, 0, max_rows, cancel).await
-    }
-
-    /// [`execute`](Self::execute), reading past the first `skip` rows without parsing or keeping them.
-    pub async fn execute_from(
-        &self,
-        sql: &str,
-        skip: usize,
-        max_rows: usize,
-        cancel: &CancellationToken,
-    ) -> IdeResult<QueryResult> {
-        if transaction_statement(sql) {
-            return Err(transaction_error());
-        }
-        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, skip.saturating_add(max_rows), *session).body(sql.to_owned());
-        let started = Instant::now();
-        let fetch = async {
-            let mut response = request.send().await.map_err(http_error)?;
-            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(skip, 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. Reads past the first `skip` rows unparsed (a later
-/// page), then keeps `max_rows` rows; later rows only set `has_more` and are read past
-/// unparsed, so a grid limit bounds memory however large the block
-/// `result_overflow_mode=break` lets the server send. A line that is not a JSON array
-/// starts the exception ClickHouse writes when a query fails mid-stream.
-struct RowReader {
-    skip: usize,
-    max_rows: usize,
-    pending: Vec<u8>,
-    names: Option<Vec<String>>,
-    types: Option<Vec<String>>,
-    rows: Vec<Vec<Option<String>>>,
-    more: bool,
-    exception: Option<String>,
-}
-
-impl RowReader {
-    fn new(skip: usize, max_rows: usize) -> Self {
-        Self {
-            skip,
-            max_rows,
-            pending: Vec::new(),
-            names: None,
-            types: None,
-            rows: Vec::new(),
-            more: false,
-            exception: None,
-        }
-    }
-
-    fn push(&mut self, chunk: &[u8]) -> IdeResult<()> {
-        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() {
-            if self.skip > 0 {
-                self.skip -= 1;
-                return Ok(());
-            }
-            if self.rows.len() >= self.max_rows {
-                self.more = true;
-                return Ok(());
-            }
-        }
-        let Ok(values) = serde_json::from_slice::<Vec<Box<serde_json::value::RawValue>>>(text) else {
-            self.exception = Some(format!("{}\n", String::from_utf8_lossy(line)));
-            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> {
-        decode_from(body, 0, max_rows, chunk)
-    }
-
-    fn decode_from(body: &[u8], skip: usize, max_rows: usize, chunk: usize) -> IdeResult<DecodedResult> {
-        let mut reader = RowReader::new(skip, max_rows);
-        for part in body.chunks(chunk) {
-            reader.push(part)?;
-        }
-        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 a_later_page_skips_rows_without_keeping_them() {
-        let body = b"[\"n\"]\n[\"UInt8\"]\n[1]\n[2]\n[3]\n[4]\n[5]\n";
-        let page = |skip, max| {
-            let (_, rows, more) = decode_from(body, skip, max, 3).unwrap();
-            (rows.into_iter().map(|r| r[0].clone().unwrap()).collect::<Vec<_>>(), more)
-        };
-        assert_eq!(page(2, 2), (vec!["3".to_owned(), "4".to_owned()], true));
-        assert_eq!(page(4, 2), (vec!["5".to_owned()], false));
-        assert_eq!(page(9, 2), (Vec::<String>::new(), false));
-    }
-
-    #[test]
-    fn rows_past_the_limit_are_skipped_but_a_later_exception_still_fails() {
-        let mut body = String::from("[\"n\"]\n[\"UInt64\"]\n");
-        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());
-    }
-}
@@ -12,17 +12,14 @@ use ide_core::{CancellationToken, IdeError, IdeResult, error::ErrorKind};
 use serde::{Deserialize, Serialize};
 use specta::Type;
 use sqlx::{
-    Column, ColumnIndex, Connection, Decode, Executor, Row, SqlSafeStr, Sqlite, TypeInfo, ValueRef,
-    mysql::{MySqlConnectOptions, MySqlConnection, MySqlSslMode},
+    Column, ColumnIndex, Connection, Decode, Executor, MySql, Postgres, Row, SqlSafeStr, Sqlite, TypeInfo, ValueRef,
+    mysql::{MySqlConnectOptions, MySqlPool, MySqlPoolOptions, MySqlSslMode},
    pool::PoolConnection,
-    postgres::{PgConnectOptions, PgConnection, PgSslMode},
+    postgres::{PgConnectOptions, PgPool, PgPoolOptions, PgSslMode},
    sqlite::{SqliteConnectOptions, SqlitePool, SqlitePoolOptions},
 };
 use std::path::{Path, PathBuf};
-use std::sync::{
-    Arc,
-    atomic::{AtomicBool, Ordering},
-};
+use std::sync::Arc;
 use std::time::{Duration, Instant};

 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
@@ -50,135 +47,12 @@ pub struct QueryResult {
    pub execution_ms: f64,
 }

-/// Session context belongs to the physical connection, including across pool checkouts.
-#[derive(Debug, Clone)]
-pub struct Context {
-    default: Option<String>,
-    current: Option<String>,
-    known: bool,
-}
-
-impl Context {
-    pub(crate) fn new(default: Option<String>) -> Self {
-        Self { current: default.clone(), default, known: true }
-    }
-
-    pub(crate) fn set_current(&mut self, current: Option<String>) {
-        self.current = current;
-    }
-
-    fn wanted(&self, driver: DbDriver, schema: Option<&str>) -> Option<String> {
-        schema
-            .filter(|s| !s.is_empty())
-            .and_then(|s| crate::sql::use_schema(driver, s))
-            .or_else(|| self.default.clone())
-    }
-}
-
-macro_rules! sqlx_pool {
-    ($manager:ident, $handle:ident, $options:ty, $connection:ty, $driver:expr, $query:expr) => {
-        pub struct $manager {
-            options: $options,
-            init: Arc<Vec<String>>,
-            timeout: Duration,
-        }
-
-        pub struct $handle {
-            conn: Option<$connection>,
-            context: Context,
-            options: $options,
-            init: Arc<Vec<String>>,
-            timeout: Duration,
-            in_transaction: bool,
-        }
-
-        impl std::ops::Deref for $handle {
-            type Target = $connection;
-            fn deref(&self) -> &Self::Target {
-                self.conn.as_ref().expect("live connection")
-            }
-        }
-
-        impl std::ops::DerefMut for $handle {
-            fn deref_mut(&mut self) -> &mut Self::Target {
-                self.conn.as_mut().expect("live connection")
-            }
-        }
-
-        impl ManageConnection for $manager {
-            type Connection = $handle;
-            type Error = sqlx::Error;
-
-            async fn connect(&self) -> Result<Self::Connection, Self::Error> {
-                tokio::time::timeout(self.timeout, async {
-                    let mut conn = <$connection>::connect_with(&self.options).await?;
-                    let context_sql = |value: Option<String>| {
-                        value.map(|v| {
-                            if $driver == DbDriver::Postgres {
-                                format!("SET search_path TO {v}")
-                            } else {
-                                crate::sql::use_schema($driver, &v).expect("switchable driver")
-                            }
-                        })
-                    };
-                    for sql in self.init.iter() {
-                        sqlx::raw_sql(sqlx::AssertSqlSafe(sql.clone())).execute(&mut conn).await?;
-                    }
-                    let row = sqlx::raw_sql(sqlx::AssertSqlSafe($query.to_owned())).fetch_one(&mut conn).await?;
-                    let context = Context::new(context_sql(row.try_get(0)?));
-                    Ok($handle {
-                        conn: Some(conn),
-                        context,
-                        options: self.options.clone(),
-                        init: self.init.clone(),
-                        timeout: self.timeout,
-                        in_transaction: false,
-                    })
-                })
-                .await
-                .map_err(|_| sqlx::Error::PoolTimedOut)?
-            }
-
-            async fn is_valid(&self, conn: &mut Self::Connection) -> Result<(), Self::Error> {
-                conn.ping().await
-            }
-
-            fn has_broken(&self, conn: &mut Self::Connection) -> bool {
-                conn.conn.is_none()
-            }
-        }
-    };
-}
-
-sqlx_pool!(PgManager, PgHandle, PgConnectOptions, PgConnection, DbDriver::Postgres, "SHOW search_path");
-sqlx_pool!(MysqlManager, MysqlHandle, MySqlConnectOptions, MySqlConnection, DbDriver::Mysql, "SELECT DATABASE()");
-
-pub struct ServerPool<M: ManageConnection> {
-    inner: Bb8Pool<M>,
-    closed: AtomicBool,
-}
-
-impl<M: ManageConnection> ServerPool<M> {
-    async fn get(&self) -> IdeResult<bb8::PooledConnection<'static, M>>
-    where
-        M::Error: std::fmt::Display,
-    {
-        if self.closed.load(Ordering::Relaxed) {
-            return Err(IdeError::new(ErrorKind::Io, "database connection is closed"));
-        }
-        self.inner.get_owned().await.map_err(|e| match e {
-            bb8::RunError::User(e) => IdeError::new(ErrorKind::Io, e.to_string()),
-            bb8::RunError::TimedOut => IdeError::new(ErrorKind::Io, "timed out connecting to the database"),
-        })
-    }
-}
-
 // Keep an empty slot when a connection is discarded after cancellation or rollback failure.
 pub struct MssqlConnectionManager(tiberius::Config);

 type MssqlClient = tiberius::Client<tokio_util::compat::Compat<tokio::net::TcpStream>>;

-pub struct MssqlConnection(Option<MssqlClient>, Context);
+pub struct MssqlConnection(Option<MssqlClient>);

 impl std::ops::Deref for MssqlConnection {
    type Target = MssqlClient;
@@ -202,7 +76,7 @@ impl ManageConnection for MssqlConnectionManager {

        let tcp = tokio::net::TcpStream::connect(self.0.get_addr()).await?;
        tcp.set_nodelay(true)?;
-        let mut client = match MssqlClient::connect(self.0.clone(), tcp.compat_write()).await {
+        let client = match MssqlClient::connect(self.0.clone(), tcp.compat_write()).await {
            // Preserve the single redirect supported by the previous pool adapter.
            Err(tiberius::error::Error::Routing { host, port }) => {
                let mut config = self.0.clone();
@@ -214,11 +88,7 @@ impl ManageConnection for MssqlConnectionManager {
            }
            result => result?,
        };
-        let row = client.simple_query("SELECT DB_NAME()").await?.into_row().await?;
-        let default = row
-            .and_then(|r| r.get::<&str, _>(0).map(str::to_owned))
-            .and_then(|db| crate::sql::use_schema(DbDriver::SqlServer, &db));
-        Ok(MssqlConnection(Some(client), Context::new(default)))
+        Ok(MssqlConnection(Some(client)))
    }

    async fn is_valid(&self, conn: &mut Self::Connection) -> Result<(), Self::Error> {
@@ -233,11 +103,21 @@ impl ManageConnection for MssqlConnectionManager {

 pub enum Pool {
    Sqlite(SqlitePool),
-    Postgres(ServerPool<PgManager>),
-    Mysql(ServerPool<MysqlManager>),
+    Postgres(PgPool),
+    Mysql(MySqlPool),
    SqlServer(Bb8Pool<MssqlConnectionManager>),
-    Clickhouse(crate::clickhouse::ClickhousePool),
-    Oracle(crate::oracle::OraclePool),
+}
+
+/// Runs `$body` with `$p` bound to the concrete pool of each driver.
+macro_rules! with_pool {
+    ($pool:expr, $p:ident => $body:expr) => {
+        match $pool {
+            Pool::Sqlite($p) => $body,
+            Pool::Postgres($p) => $body,
+            Pool::Mysql($p) => $body,
+            Pool::SqlServer(_) => unreachable!(),
+        }
+    };
 }

 pub(crate) fn db_err(e: sqlx::Error) -> IdeError {
@@ -381,7 +261,7 @@ fn tiberius_cell(cell: &tiberius::ColumnData<'_>, ty: tiberius::ColumnType) -> O
    }
 }

-pub(crate) fn hex(bytes: &[u8]) -> String {
+fn hex(bytes: &[u8]) -> String {
    let mut s = String::with_capacity(2 + bytes.len() * 2);
    s.push_str("0x");
    for b in bytes {
@@ -456,13 +336,10 @@ fn result_columns<R: Row>(row: &R) -> Vec<ResultColumn> {
        .collect()
 }

-/// Streams the results of `$sql` on executor `$exec`, reading past the first `$skip`
-/// rows without decoding them, then keeping at most `$max` rows with their cells read as `$mode`.
+/// Streams the results of `$sql` on executor `$exec`, keeping at most `$max` rows
+/// with their cells read as `$mode`.
 macro_rules! fetch {
-    ($exec:expr, $sql:expr, $max:expr, $mode:expr) => {
-        fetch!($exec, $sql, 0usize, $max, $mode)
-    };
-    ($exec:expr, $sql:expr, $skip:expr, $max:expr, $mode:expr) => {{
+    ($exec:expr, $sql:expr, $max:expr, $mode:expr) => {{
        use futures::StreamExt;
        let mut stream = sqlx::raw_sql(sqlx::AssertSqlSafe($sql.to_owned())).fetch_many($exec);
        let mut columns: Vec<ResultColumn> = Vec::new();
@@ -471,7 +348,6 @@ macro_rules! fetch {
        let mut has_more = false;
        let mut failure = None;
        let mut first: Option<Instant> = None;
-        let mut to_skip: usize = $skip;
        while let Some(item) = stream.next().await {
            first.get_or_insert_with(Instant::now);
            match item {
@@ -480,10 +356,6 @@ macro_rules! fetch {
                    if columns.is_empty() {
                        columns = result_columns(&row);
                    }
-                    if to_skip > 0 {
-                        to_skip -= 1;
-                        continue;
-                    }
                    if rows.len() >= $max {
                        has_more = true;
                        break;
@@ -505,7 +377,7 @@ macro_rules! fetch {
 }

 /// Columns, rows, rows affected, more rows beyond the limit, time of the first answer.
-pub(crate) type Fetched = (Vec<ResultColumn>, Vec<Vec<Option<String>>>, Option<u64>, bool, Option<Instant>);
+type Fetched = (Vec<ResultColumn>, Vec<Vec<Option<String>>>, Option<u64>, bool, Option<Instant>);

 async fn mssql_command(conn: &mut MssqlClient, sql: &str) -> IdeResult<()> {
    // Transaction control must be a batch: sp_executesql rejects a changed transaction count.
@@ -513,8 +385,7 @@ async fn mssql_command(conn: &mut MssqlClient, sql: &str) -> IdeResult<()> {
    Ok(())
 }

-/// Like [`fetch!`] for SQL Server: the first `skip` rows are read past without decoding.
-async fn mssql_fetch(conn: &mut MssqlClient, sql: &str, skip: usize, max: usize) -> IdeResult<Fetched> {
+async fn mssql_fetch(conn: &mut MssqlClient, sql: &str, max: usize) -> IdeResult<Fetched> {
    let mut stream = conn.simple_query(sql).await.map_err(mssql_err)?;
    let first = Some(Instant::now());
    let columns = stream
@@ -527,13 +398,8 @@ async fn mssql_fetch(conn: &mut MssqlClient, sql: &str, skip: usize, max: usize)
        .collect();
    let mut rows = Vec::new();
    let mut has_more = false;
-    let mut to_skip = skip;
    while let Some(item) = stream.next().await {
        if let tiberius::QueryItem::Row(row) = item.map_err(mssql_err)? {
-            if to_skip > 0 {
-                to_skip -= 1;
-                continue;
-            }
            if rows.len() >= max {
                has_more = true;
                break;
@@ -556,19 +422,6 @@ macro_rules! backend_id {
    }};
 }

-// Session control, scripts and PostgreSQL set_config can invalidate the tracked context.
-fn context_may_change(sql: &str) -> bool {
-    let text = sql.trim().trim_end_matches(';');
-    text.contains(';')
-        || text.to_ascii_lowercase().contains("set_config")
-        || !text.split_whitespace().next().is_some_and(|s| {
-            matches!(
-                s.to_ascii_uppercase().as_str(),
-                "SELECT" | "INSERT" | "UPDATE" | "DELETE" | "CREATE" | "DROP" | "TRUNCATE" | "SHOW" | "EXPLAIN"
-            )
-        })
-}
-
 fn looks_like_query(sql: &str) -> bool {
    let first = sql
        .lines()
@@ -635,18 +488,6 @@ impl Setup {
                }
            }
            DbDriver::Mysql if source.read_only => s.statements.push("SET SESSION TRANSACTION READ ONLY".into()),
-            DbDriver::Oracle => {
-                let schema = o.default_schema.trim();
-                if !schema.is_empty() {
-                    if !is_identifier(schema) {
-                        return Err(IdeError::invalid(format!("invalid schema name: {schema}")));
-                    }
-                    s.statements.push(format!("ALTER SESSION SET CURRENT_SCHEMA = {schema}"));
-                }
-                if !o.time_zone.trim().is_empty() {
-                    s.statements.push(format!("ALTER SESSION SET TIME_ZONE = {}", mysql_value(o.time_zone.trim())));
-                }
-            }
            _ => {}
        }
        for p in &source.properties {
@@ -662,30 +503,15 @@ 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") => {
-                    let seconds = number(&name)?;
-                    if seconds == 0 {
-                        return Err(IdeError::invalid("connect_timeout must be greater than zero"));
-                    }
-                    s.connect_timeout = Some(Duration::from_secs(seconds));
-                }
+                (_, "connect_timeout") => s.connect_timeout = Some(Duration::from_secs(number(&name)?)),
                (DbDriver::Postgres, "application_name") => s.application_name = Some(value.to_owned()),
                (DbDriver::Mysql, "charset") => s.charset = Some(value.to_owned()),
                (DbDriver::Mysql, "collation") => s.collation = Some(value.to_owned()),
                (DbDriver::Mysql, _) => s.statements.push(format!("SET SESSION {name} = {}", mysql_value(value))),
-                (DbDriver::Oracle, _) => {
-                    s.statements.push(format!("ALTER SESSION SET {name} = {}", mysql_value(value)))
-                }
                _ => 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));
@@ -701,16 +527,6 @@ impl Pool {
            Pool::Postgres(_) => DbDriver::Postgres,
            Pool::Mysql(_) => DbDriver::Mysql,
            Pool::SqlServer(_) => DbDriver::SqlServer,
-            Pool::Clickhouse(_) => DbDriver::Clickhouse,
-            Pool::Oracle(_) => DbDriver::Oracle,
-        }
-    }
-
-    /// The keep-alive ping (Oracle needs a FROM clause).
-    pub fn ping_sql(&self) -> &'static str {
-        match self {
-            Pool::Oracle(_) => "SELECT 1 FROM DUAL",
-            _ => "SELECT 1",
        }
    }

@@ -718,12 +534,6 @@ 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);
-        }
-        if source.driver == DbDriver::Oracle {
-            return crate::oracle::OraclePool::connect(source, password, &setup).await.map(Pool::Oracle);
-        }
        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.
@@ -799,12 +609,14 @@ impl Pool {
                if let Some(n) = setup.statement_cache {
                    opts = opts.statement_cache_capacity(n);
                }
-                let manager = PgManager { options: opts, init: init.clone(), timeout };
-                // Open once directly so authentication failures retain their database error.
-                let first = manager.connect().await.map_err(db_err)?;
-                let pool = Bb8Pool::builder().max_size(MAX).connection_timeout(timeout).build_unchecked(manager);
-                let _ = pool.add(first);
-                Ok(Pool::Postgres(ServerPool { inner: pool, closed: AtomicBool::new(false) }))
+                let pool = PgPoolOptions::new()
+                    .max_connections(MAX)
+                    .acquire_timeout(timeout)
+                    .after_connect(after_connect!())
+                    .connect_with(opts)
+                    .await
+                    .map_err(db_err)?;
+                Ok(Pool::Postgres(pool))
            }
            DbDriver::Mysql => {
                let mut opts = MySqlConnectOptions::new()
@@ -846,12 +658,14 @@ impl Pool {
                if !tz.is_empty() {
                    opts = opts.timezone(Some(tz.to_owned()));
                }
-                let manager = MysqlManager { options: opts, init: init.clone(), timeout };
-                // Open once directly so authentication failures retain their database error.
-                let first = manager.connect().await.map_err(db_err)?;
-                let pool = Bb8Pool::builder().max_size(MAX).connection_timeout(timeout).build_unchecked(manager);
-                let _ = pool.add(first);
-                Ok(Pool::Mysql(ServerPool { inner: pool, closed: AtomicBool::new(false) }))
+                let pool = MySqlPoolOptions::new()
+                    .max_connections(MAX)
+                    .acquire_timeout(timeout)
+                    .after_connect(after_connect!())
+                    .connect_with(opts)
+                    .await
+                    .map_err(db_err)?;
+                Ok(Pool::Mysql(pool))
            }
            DbDriver::SqlServer => {
                use tiberius::Config;
@@ -881,66 +695,40 @@ 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!(),
-            DbDriver::Oracle => unreachable!(),
        }
    }

    pub async fn close(&self) {
        match self {
-            Pool::SqlServer(_) | Pool::Oracle(_) => {}
-            Pool::Clickhouse(p) => p.close(),
-            Pool::Sqlite(p) => p.close().await,
-            Pool::Postgres(p) => p.closed.store(true, Ordering::Relaxed),
-            Pool::Mysql(p) => p.closed.store(true, Ordering::Relaxed),
+            Pool::SqlServer(_) => {}
+            _ => with_pool!(self, p => p.close().await),
        }
    }

    pub fn is_closed(&self) -> bool {
        match self {
            Pool::SqlServer(_) => false,
-            Pool::Oracle(p) => p.is_closed(),
-            Pool::Clickhouse(p) => p.is_closed(),
-            Pool::Sqlite(p) => p.is_closed(),
-            Pool::Postgres(p) => p.closed.load(Ordering::Relaxed),
-            Pool::Mysql(p) => p.closed.load(Ordering::Relaxed),
+            _ => 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 mut conn = Held::acquire(self).await?;
-        conn.apply_context(None).await?;
-        let fetched = conn.fetch_rows(sql, max).await;
+        let fetched: IdeResult<Fetched> = match self {
+            Pool::SqlServer(p) => {
+                let mut conn = p.get_owned().await.map_err(mssql_pool_err)?;
+                mssql_fetch(&mut conn, sql, max).await
+            }
+            _ => with_pool!(self, p => fetch!(p, sql, max, Cells::Text)),
+        };
        Ok(fetched?.1)
    }

    /// Runs one statement and keeps at most `max_rows` rows. Cancelling stops
    /// the statement on the server (PostgreSQL, MySQL) and drops the connection.
    pub async fn execute(&self, sql: &str, max_rows: usize, cancel: &CancellationToken) -> IdeResult<QueryResult> {
-        self.execute_from(sql, 0, max_rows, cancel).await
-    }
-
-    /// [`execute`](Self::execute), reading past the first `skip` rows without keeping them
-    /// (a later page of a result: only that page is decoded and returned).
-    pub async fn execute_from(
-        &self,
-        sql: &str,
-        skip: usize,
-        max_rows: usize,
-        cancel: &CancellationToken,
-    ) -> IdeResult<QueryResult> {
-        if let Pool::Clickhouse(p) = self {
-            return p.execute_from(sql, skip, max_rows, cancel).await;
-        }
        let mut conn = Held::acquire(self).await?;
-        let r = match conn.apply_context(None).await {
-            Ok(()) => conn.execute_from(self, sql, skip, max_rows, cancel).await,
-            Err(e) => Err(e),
-        };
+        let r = conn.execute(self, sql, max_rows, cancel).await;
        if cancel.is_cancelled() {
            conn.discard().await;
            return Err(IdeError::cancelled());
@@ -952,11 +740,8 @@ 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(_) => {
-                let mut held = Held::acquire(self).await?;
-                held.apply_context(None).await?;
-                let Held::SqlServer(mut conn) = held else { unreachable!() };
+            Pool::SqlServer(p) => {
+                let mut conn = p.get_owned().await.map_err(mssql_pool_err)?;
                let result = async {
                    mssql_command(&mut conn, "BEGIN TRAN").await?;
                    let mut total = 0;
@@ -979,48 +764,21 @@ impl Pool {
                }
                result
            }
-            Pool::Oracle(_) => {
-                let mut held = Held::acquire(self).await?;
-                held.apply_context(None).await?;
-                let Held::Oracle(mut conn) = held else { unreachable!() };
-                let result = crate::oracle::transaction(&mut conn, statements).await;
-                if result.is_err() {
-                    // An open transaction must never return to the pool with the connection.
-                    conn.discard_inner();
+            _ => with_pool!(self, p => {
+                let mut tx = p.begin().await.map_err(db_err)?;
+                let mut total = 0;
+                for (sql, expect_one) in statements {
+                    let done = sqlx::raw_sql(sqlx::AssertSqlSafe(sql.clone())).execute(&mut *tx).await.map_err(db_err)?;
+                    let n = done.rows_affected();
+                    // MySQL reports 0 for an UPDATE that leaves the row unchanged.
+                    if *expect_one && (n > 1 || (n == 0 && !matches!(self, Pool::Mysql(_)))) {
+                        return Err(IdeError::invalid(format!("{sql}: expected to change 1 row, changed {n}; nothing was saved")));
+                    }
+                    total += n;
                }
-                result
-            }
-            _ => {
-                let mut conn = Held::acquire(self).await?;
-                conn.apply_context(None).await?;
-                macro_rules! transaction {
-                    ($c:expr) => {{
-                        let mut tx = (&mut **$c).begin().await.map_err(db_err)?;
-                        let mut total = 0;
-                        for (sql, expect_one) in statements {
-                            let done = sqlx::raw_sql(sqlx::AssertSqlSafe(sql.clone()))
-                                .execute(&mut *tx)
-                                .await
-                                .map_err(db_err)?;
-                            let n = done.rows_affected();
-                            if *expect_one && (n > 1 || (n == 0 && !matches!(self, Pool::Mysql(_)))) {
-                                return Err(IdeError::invalid(format!(
-                                    "{sql}: expected to change 1 row, changed {n}; nothing was saved"
-                                )));
-                            }
-                            total += n;
-                        }
-                        tx.commit().await.map_err(db_err)?;
-                        Ok(total)
-                    }};
-                }
-                match &mut conn {
-                    Held::Sqlite(c) => transaction!(c),
-                    Held::Postgres(c) => transaction!(&mut ***c),
-                    Held::Mysql(c) => transaction!(&mut ***c),
-                    _ => unreachable!(),
-                }
-            }
+                tx.commit().await.map_err(db_err)?;
+                Ok(total)
+            }),
        }
    }
 }
@@ -1029,162 +787,32 @@ impl Pool {
 /// manual-commit console across statements with its transaction open.
 pub enum Held {
    Sqlite(PoolConnection<Sqlite>),
-    Postgres(Box<bb8::PooledConnection<'static, PgManager>>),
-    Mysql(Box<bb8::PooledConnection<'static, MysqlManager>>),
+    Postgres(PoolConnection<Postgres>),
+    Mysql(PoolConnection<MySql>),
    SqlServer(Box<bb8::PooledConnection<'static, MssqlConnectionManager>>),
-    Clickhouse(crate::clickhouse::ClickhousePool),
-    Oracle(crate::oracle::OracleConnection),
 }

 impl Held {
    pub async fn acquire(pool: &Pool) -> IdeResult<Self> {
        Ok(match pool {
            Pool::Sqlite(p) => Held::Sqlite(p.acquire().await.map_err(db_err)?),
-            Pool::Postgres(p) => Held::Postgres(Box::new(p.get().await?)),
-            Pool::Mysql(p) => Held::Mysql(Box::new(p.get().await?)),
+            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())
-            }
-            Pool::Oracle(p) => Held::Oracle(p.get().await?),
        })
    }

-    fn context(&mut self) -> Option<&mut Context> {
-        match self {
-            Held::Postgres(c) => Some(&mut c.context),
-            Held::Mysql(c) => Some(&mut c.context),
-            Held::SqlServer(c) => Some(&mut c.1),
-            Held::Oracle(c) => Some(c.context()),
-            _ => None,
-        }
-    }
-
-    fn invalidate_context(&mut self) {
-        if let Some(context) = self.context() {
-            context.known = false;
-        }
-    }
-
-    fn before_statement(&mut self, sql: &str) {
-        let control = sql.trim().trim_end_matches(';').trim().to_ascii_uppercase();
-        if let Held::Mysql(c) = self {
-            if matches!(control.as_str(), "BEGIN" | "START TRANSACTION") {
-                c.in_transaction = true;
-                return;
-            }
-            if matches!(control.as_str(), "COMMIT" | "ROLLBACK") {
-                return;
-            }
-        }
-        if context_may_change(sql) {
-            self.invalidate_context();
-        }
-    }
-
-    fn after_statement(&mut self, sql: &str) {
-        if let Held::Mysql(c) = self
-            && matches!(sql.trim().trim_end_matches(';').trim().to_ascii_uppercase().as_str(), "COMMIT" | "ROLLBACK")
-        {
-            c.in_transaction = false;
-        }
-    }
-
-    pub async fn apply_context(&mut self, schema: Option<&str>) -> IdeResult<()> {
-        let driver = match self {
-            Held::Postgres(_) => DbDriver::Postgres,
-            Held::Mysql(_) => DbDriver::Mysql,
-            Held::SqlServer(_) => DbDriver::SqlServer,
-            Held::Oracle(_) => DbDriver::Oracle,
-            _ => return Ok(()),
-        };
-        let context = self.context().expect("switchable connection");
-        let wanted = context.wanted(driver, schema);
-        if context.known && context.current == wanted {
-            return Ok(());
-        }
-        context.known = false;
-        if let Some(sql) = &wanted {
-            self.raw_command(sql).await?;
-        } else {
-            // MySQL cannot USE an absent database. Re-open with the original options.
-            macro_rules! reopen {
-                ($c:expr, $manager:ident) => {{
-                    let manager = $manager { options: $c.options.clone(), init: $c.init.clone(), timeout: $c.timeout };
-                    if $c.in_transaction {
-                        return Err(IdeError::invalid("commit or roll back before clearing the selected database"));
-                    }
-                    let fresh = manager.connect().await.map_err(db_err)?;
-                    if let Some(raw) = $c.conn.take() {
-                        let _ = raw.close().await;
-                    }
-                    ***$c = fresh;
-                }};
-            }
-            match self {
-                Held::Mysql(c) => reopen!(c, MysqlManager),
-                Held::Postgres(c) => reopen!(c, PgManager),
-                _ => unreachable!("server context has a default"),
-            }
-        }
-        let context = self.context().expect("switchable connection");
-        context.current = wanted;
-        context.known = true;
-        Ok(())
-    }
-
-    /// Restore before a manual session returns its physical connection to the pool.
-    pub async fn restore_default(&mut self) -> IdeResult<()> {
-        self.apply_context(None).await
-    }
-
-    async fn fetch_rows(&mut self, sql: &str, max: usize) -> IdeResult<Fetched> {
-        self.before_statement(sql);
-        let result = match self {
-            Held::Sqlite(c) => fetch!(&mut **c, sql, max, Cells::Text),
-            Held::Postgres(c) => fetch!(&mut ****c, sql, max, Cells::Text),
-            Held::Mysql(c) => fetch!(&mut ****c, sql, max, Cells::Text),
-            Held::SqlServer(c) => mssql_fetch(c, sql, 0, max).await,
-            Held::Oracle(c) => crate::oracle::run(c, sql, 0, max, Cells::Text, &CancellationToken::new()).await,
-            Held::Clickhouse(_) => unreachable!(),
-        };
-        if result.is_ok() {
-            self.after_statement(sql);
-        }
-        result
-    }
-
    /// Runs a statement without results (`BEGIN`, `COMMIT`, `ROLLBACK`).
    pub async fn command(&mut self, sql: &str) -> IdeResult<()> {
-        self.before_statement(sql);
-        let result = self.raw_command(sql).await;
-        if result.is_ok() {
-            self.after_statement(sql);
-        }
-        result
-    }
-
-    async fn raw_command(&mut self, sql: &str) -> IdeResult<()> {
        match self {
            Held::SqlServer(c) => mssql_command(c, sql).await,
-            Held::Clickhouse(_) => Err(crate::clickhouse::transaction_error()),
-            Held::Oracle(c) => {
-                let sql = sql.trim();
-                if sql.is_empty() {
-                    return Ok(()); // Oracle transactions open implicitly.
-                }
-                crate::oracle::run(c, sql, 0, 0, Cells::Text, &CancellationToken::new()).await.map(drop)
-            }
            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(_) | Held::Clickhouse(_) | Held::Oracle(_) => unreachable!(),
+                    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!(),
                }
                .map_err(db_err)
            }
@@ -1196,21 +824,15 @@ impl Held {
    pub async fn discard(self) {
        match self {
            Held::Sqlite(c) => drop(c.detach()),
-            Held::Postgres(mut c) => {
-                if let Some(raw) = c.conn.take() {
-                    let _ = raw.close().await;
-                }
+            Held::Postgres(c) => {
+                let _ = c.detach().close().await;
            }
-            Held::Mysql(mut c) => {
-                if let Some(raw) = c.conn.take() {
-                    let _ = raw.close().await;
-                }
+            Held::Mysql(c) => {
+                let _ = c.detach().close().await;
            }
            Held::SqlServer(mut c) => {
                c.0.take();
            }
-            Held::Clickhouse(_) => {}
-            Held::Oracle(mut c) => c.discard_inner(),
        }
    }

@@ -1223,23 +845,6 @@ impl Held {
        max_rows: usize,
        cancel: &CancellationToken,
    ) -> IdeResult<QueryResult> {
-        self.execute_from(pool, sql, 0, max_rows, cancel).await
-    }
-
-    /// [`execute`](Self::execute), reading past the first `skip` rows without keeping them
-    /// (see [`Pool::execute_from`]).
-    pub async fn execute_from(
-        &mut self,
-        pool: &Pool,
-        sql: &str,
-        skip: usize,
-        max_rows: usize,
-        cancel: &CancellationToken,
-    ) -> IdeResult<QueryResult> {
-        if let Held::Clickhouse(c) = self {
-            return c.execute_from(sql, skip, max_rows, cancel).await;
-        }
-        self.before_statement(sql);
        let started = Instant::now();
        // `$id`: the query naming the server process, `$kill`: how another connection stops it.
        macro_rules! run {
@@ -1249,7 +854,7 @@ impl Held {
                    None => None,
                };
                let r = tokio::select! {
-                    r = async { fetch!(&mut **$conn, sql, skip, max_rows, Cells::Display) } => r,
+                    r = async { fetch!(&mut **$conn, sql, max_rows, Cells::Display) } => r,
                    () = cancel.cancelled() => Err(IdeError::cancelled()),
                };
                if cancel.is_cancelled() {
@@ -1272,20 +877,17 @@ impl Held {
        let fetched: Fetched = match self {
            Held::Sqlite(c) => run!(c, None::<&str>, |_: String| String::new()),
            Held::Postgres(c) => {
-                run!(&mut ***c, Some("SELECT pg_backend_pid()"), |b: String| format!("SELECT pg_cancel_backend({b})"))
+                run!(c, Some("SELECT pg_backend_pid()"), |b: String| format!("SELECT pg_cancel_backend({b})"))
            }
-            Held::Mysql(c) => run!(&mut ***c, Some("SELECT CONNECTION_ID()"), |b: String| format!("KILL QUERY {b}")),
+            Held::Mysql(c) => run!(c, Some("SELECT CONNECTION_ID()"), |b: String| format!("KILL QUERY {b}")),
            Held::SqlServer(c) => {
                // Tiberius has no attention/cancel API; stop reading and discard the connection.
                tokio::select! {
-                    r = mssql_fetch(c, sql, skip, max_rows) => r?,
+                    r = mssql_fetch(c, sql, max_rows) => r?,
                    () = cancel.cancelled() => return Err(IdeError::cancelled()),
                }
            }
-            Held::Oracle(c) => crate::oracle::run(c, sql, skip, max_rows, Cells::Display, cancel).await?,
-            Held::Clickhouse(_) => unreachable!(),
        };
-        self.after_statement(sql);
        let (columns, rows, affected, has_more, first) = fetched;
        let elapsed_ms = started.elapsed().as_secs_f64() * 1000.0;
        Ok(QueryResult {
@@ -1305,8 +907,7 @@ pub fn begin_statement(driver: DbDriver) -> &'static str {
    match driver {
        DbDriver::Mysql => "START TRANSACTION",
        DbDriver::SqlServer => "BEGIN TRAN",
-        DbDriver::Oracle => "", // opens implicitly with autocommit off
-        DbDriver::Sqlite | DbDriver::Postgres | DbDriver::Clickhouse => "BEGIN",
+        DbDriver::Sqlite | DbDriver::Postgres => "BEGIN",
    }
 }

@@ -1325,7 +926,7 @@ mod tests {
    #[test]
    fn discarded_sqlserver_connections_are_broken() {
        let manager = MssqlConnectionManager(tiberius::Config::new());
-        assert!(manager.has_broken(&mut MssqlConnection(None, Context::new(None))));
+        assert!(manager.has_broken(&mut MssqlConnection(None)));
    }

    #[tokio::test]
@@ -1461,7 +1062,6 @@ mod tests {
        assert_eq!(setup.charset.as_deref(), Some("utf8mb4"));
        assert_eq!(setup.connect_timeout, Some(Duration::from_secs(5)));
        assert!(Setup::of(&DataSource { properties: vec![prop("a; drop", "1")], ..s.clone() }).is_err());
-        assert!(Setup::of(&DataSource { properties: vec![prop("connect_timeout", "0")], ..s.clone() }).is_err());
        assert!(Setup::of(&DataSource { properties: vec![prop("connect_timeout", "soon")], ..s }).is_err());
    }

@@ -2,10 +2,8 @@
 //! 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;
-mod oracle;
 pub mod plan;
 pub mod secrets;
 pub mod source;
@@ -214,8 +212,6 @@ pub struct DbManager {
    /// App-wide SSH connections and host-key trust.
    ssh: Arc<SshManager>,
    saved_passwords: SecretStore,
-    /// Directory of the global data sources and their saved passwords ([`DbManager::with_global_sources`]).
-    global: Option<(PathBuf, SecretStore)>,
    history: Arc<HistoryStore>,
    /// Records executed statements in the history off the async threads, in order.
    recorder: std::sync::mpsc::Sender<(String, String, f64)>,
@@ -304,7 +300,7 @@ fn keep_alive(pool: &Arc<Pool>, every: Duration) {
        loop {
            tick.tick().await;
            let Some(p) = pool.upgrade().filter(|p| !p.is_closed()) else { break };
-            if let Err(e) = p.rows(p.ping_sql(), 1).await {
+            if let Err(e) = p.rows("SELECT 1", 1).await {
                tracing::debug!("keep-alive: {}", e.message);
            }
        }
@@ -315,7 +311,7 @@ fn keep_alive(pool: &Arc<Pool>, every: Duration) {
 async fn end_session(session: &Session) {
    let held = session.lock().await.take();
    if let Some(mut conn) = held
-        && (conn.command("ROLLBACK").await.is_err() || conn.restore_default().await.is_err())
+        && conn.command("ROLLBACK").await.is_err()
    {
        conn.discard().await;
    }
@@ -342,7 +338,6 @@ impl DbManager {
        }
        Self {
            saved_passwords: SecretStore::new(passwords, &root),
-            global: None,
            history,
            recorder,
            root,
@@ -355,42 +350,8 @@ impl DbManager {
        }
    }

-    /// Also lists the global data sources stored in `dir` (the app data directory).
-    pub fn with_global_sources(mut self, dir: PathBuf) -> Self {
-        let passwords = self.saved_passwords.scoped(&dir);
-        self.global = Some((dir, passwords));
-        self
-    }
-
-    /// The project's data sources, then the global ones (a project one wins on the same id).
    pub fn sources(&self) -> IdeResult<Vec<DataSource>> {
-        let mut all = source::load(&self.root)?;
-        let global: Vec<_> = self.global_sources().into_iter().filter(|g| all.iter().all(|s| s.id != g.id)).collect();
-        all.extend(global);
-        Ok(all)
-    }
-
-    fn global_sources(&self) -> Vec<DataSource> {
-        let Some((dir, _)) = &self.global else { return Vec::new() };
-        source::load_global(dir).unwrap_or_else(|e| {
-            tracing::warn!("global data sources: {}", e.message);
-            Vec::new()
-        })
-    }
-
-    /// Where the saved passwords of data source `id` live: app-wide for a global one.
-    fn saved_for(&self, id: &str) -> &SecretStore {
-        match &self.global {
-            Some((_, store)) if self.global_sources().iter().any(|s| s.id == id) => store,
-            _ => &self.saved_passwords,
-        }
-    }
-
-    fn store_of(&self, source: &DataSource) -> &SecretStore {
-        match &self.global {
-            Some((_, store)) if source.global => store,
-            _ => &self.saved_passwords,
-        }
+        source::load(&self.root)
    }

    /// The connection settings of target `target` ([`DataSource::resolved`]), with
@@ -410,43 +371,18 @@ impl DbManager {
    }

    /// Saves the data source list; connections of removed or changed sources are closed.
-    /// Global ones (`global`) go to the app-wide list, the others to the project's.
    pub async fn save_sources(&self, sources: Vec<DataSource>) -> IdeResult<()> {
        let old = self.sources().unwrap_or_default();
-        let (global, project): (Vec<_>, Vec<_>) = sources.iter().cloned().partition(|s| s.global);
-        match &self.global {
-            // Rewritten only when it changes: other projects' windows edit the same file.
-            Some((dir, _)) => {
-                if global != old.iter().filter(|s| s.global).cloned().collect::<Vec<_>>() {
-                    source::save_global(dir, &global)?;
-                }
-            }
-            None if !global.is_empty() => return Err(IdeError::invalid("global data sources are not available here")),
-            None => {}
-        }
-        source::save(&self.root, &project)?;
+        source::save(&self.root, &sources)?;
        for o in old {
            match sources.iter().find(|s| s.id == o.id) {
                Some(n) if *n == o => {}
                gone_or_changed => {
-                    let keys = [o.id.clone(), secrets::ssh_key(&o.id)];
-                    match gone_or_changed {
-                        None => {
-                            for k in &keys {
-                                self.session_passwords.lock().remove(k);
-                                self.store_of(&o).delete(k);
-                            }
+                    if gone_or_changed.is_none() {
+                        for k in [o.id.clone(), secrets::ssh_key(&o.id)] {
+                            self.session_passwords.lock().remove(&k);
+                            self.saved_passwords.delete(&k);
                        }
-                        // Made global or project-level: its saved passwords move along.
-                        Some(n) if n.global != o.global => {
-                            for k in &keys {
-                                if let Some(p) = self.store_of(&o).get(k) {
-                                    self.store_of(n).set(k, &p)?;
-                                    self.store_of(&o).delete(k);
-                                }
-                            }
-                        }
-                        Some(_) => {}
                    }
                    self.disconnect_source(&o.id).await;
                }
@@ -458,7 +394,7 @@ impl DbManager {
    /// Remembers `password` for the session, and in the saved passwords when
    /// the data source saves passwords (`None` forgets it).
    pub async fn set_password(&self, id: &str, password: Option<String>, save: bool) -> IdeResult<()> {
-        self.remember(id, id.to_owned(), password, save).await
+        self.remember(id.to_owned(), password, save).await
    }

    /// [`DbManager::set_password`] for the SSH password / key passphrase.
@@ -470,10 +406,10 @@ impl DbManager {
            self.ssh.set_secret(&c, secret, save);
            return Ok(());
        }
-        self.remember(id, secrets::ssh_key(id), secret, save).await
+        self.remember(secrets::ssh_key(id), secret, save).await
    }

-    async fn remember(&self, id: &str, key: String, secret: Option<String>, save: bool) -> IdeResult<()> {
+    async fn remember(&self, key: String, secret: Option<String>, save: bool) -> IdeResult<()> {
        match &secret {
            Some(p) => {
                self.session_passwords.lock().insert(key.clone(), p.clone());
@@ -482,11 +418,10 @@ impl DbManager {
                self.session_passwords.lock().remove(&key);
            }
        }
-        let store = self.saved_for(id);
        let result = match (secret, save) {
-            (Some(p), true) => store.set(&key, &p),
+            (Some(p), true) => self.saved_passwords.set(&key, &p),
            _ => {
-                store.delete(&key);
+                self.saved_passwords.delete(&key);
                Ok(())
            }
        };
@@ -497,18 +432,18 @@ impl DbManager {
        Ok(())
    }

-    async fn secret(&self, source: &DataSource, key: String, saved: bool) -> Option<String> {
+    async fn secret(&self, key: String, saved: bool) -> Option<String> {
        if let Some(p) = self.session_passwords.lock().get(&key) {
            return Some(p.clone());
        }
        if !saved {
            return None;
        }
-        self.store_of(source).get(&key)
+        self.saved_passwords.get(&key)
    }

    async fn password(&self, source: &DataSource) -> Option<String> {
-        match self.secret(source, source.id.clone(), source.driver != DbDriver::Sqlite && source.save_password).await {
+        match self.secret(source.id.clone(), source.driver != DbDriver::Sqlite && source.save_password).await {
            Some(p) => Some(p),
            None => source.url_password(),
        }
@@ -564,7 +499,7 @@ impl DbManager {
        let session = if config.is_empty() {
            let secret = match ssh_secret {
                Some(s) => Some(s),
-                None => self.secret(source, secrets::ssh_key(&source.id), ssh.save_secret).await,
+                None => self.secret(secrets::ssh_key(&source.id), ssh.save_secret).await,
            };
            let target = SshTarget {
                host: ssh.host.clone(),
@@ -612,15 +547,12 @@ impl DbManager {
        })?;
        let version = match source.driver {
            DbDriver::Sqlite => "SELECT 'SQLite ' || sqlite_version()",
-            DbDriver::Postgres | DbDriver::Clickhouse => "SELECT version()",
+            DbDriver::Postgres => "SELECT version()",
            DbDriver::Mysql => "SELECT CONCAT(@@version_comment, ' ', VERSION())",
            DbDriver::SqlServer => "SELECT @@VERSION",
-            DbDriver::Oracle => "SELECT banner FROM v$version WHERE banner LIKE 'Oracle%' AND ROWNUM = 1",
        };
-        let result = pool.rows(version, 1).await;
+        let v = pool.rows(version, 1).await.ok().and_then(|r| r.into_iter().next()?.into_iter().next()?);
        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()))
    }

@@ -704,15 +636,8 @@ impl DbManager {
        let introspection = self.source(id)?.introspection;
        let system = introspection.show_system;
        let pool = self.pool(id).await?;
-        if pool.driver() == DbDriver::SqlServer {
-            let first =
-                |rows: Vec<Vec<Option<String>>>| rows.into_iter().filter_map(|r| r.into_iter().next().flatten());
-            let current = first(pool.rows("SELECT DB_NAME()", 1).await?).next().unwrap_or_default();
-            let names = first(pool.rows(sql::sqlserver_databases(), MAX_META_ROWS).await?).collect();
-            return Ok(Databases { current, names });
-        }
        if pool.driver() != DbDriver::Postgres {
-            return Err(IdeError::invalid("this data source does not list databases"));
+            return Err(IdeError::invalid("only PostgreSQL data sources list databases"));
        }
        let first = |rows: Vec<Vec<Option<String>>>| rows.into_iter().filter_map(|r| r.into_iter().next().flatten());
        let current = first(pool.rows("SELECT current_database()", 1).await?).next().unwrap_or_default();
@@ -776,11 +701,8 @@ impl DbManager {
                _ => indexes.push(IndexInfo { name, unique: flag(&unique), columns: vec![col] }),
            }
        }
-        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 fk_rows =
+            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()) {
@@ -793,15 +715,13 @@ impl DbManager {
                .collect();
        }
        foreign_keys.retain(|k| k.columns.len() == k.ref_columns.len());
-        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| {
+        let triggers = 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();
@@ -902,11 +822,6 @@ 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)
@@ -914,33 +829,6 @@ impl DbManager {
                    .next();
                ddl.map(|d| format!("{d};\n")).ok_or_else(missing)
            }
-            DbDriver::Oracle => {
-                let (s, n) = (sql::quote_literal(driver, schema), sql::quote_literal(driver, name));
-                let kind = pool
-                    .rows(
-                        &format!(
-                            "SELECT object_type FROM all_objects WHERE owner = {s} AND object_name = {n} \
-                             AND object_type IN ('TABLE', 'VIEW') AND ROWNUM = 1"
-                        ),
-                        1,
-                    )
-                    .await?
-                    .into_iter()
-                    .next()
-                    .and_then(|r| r.into_iter().next().flatten())
-                    .ok_or_else(missing)?;
-                let ddl = cells(
-                    pool.rows(
-                        &format!("SELECT DBMS_METADATA.GET_DDL('{}', {n}, {s}) FROM DUAL", kind.replace('\'', "''")),
-                        1,
-                    )
-                    .await?,
-                    0,
-                )
-                .into_iter()
-                .next();
-                ddl.map(|d| format!("{};\n", d.trim_end().trim_end_matches(';'))).ok_or_else(missing)
-            }
            DbDriver::Postgres => {
                let rel = pool.rows(&sql::postgres_relation(schema, name), 1).await?.into_iter().next();
                let (oid, kind) = match rel.as_deref() {
@@ -1014,14 +902,10 @@ impl DbManager {
            }
        }
        // Foreign keys are a nicety (JOIN completion): a server that refuses the catalog query still completes.
-        let fk_rows = if driver == DbDriver::Clickhouse {
+        let fk_rows = pool.rows(sql::foreign_keys(driver), MAX_META_ROWS).await.unwrap_or_else(|e| {
+            tracing::warn!("foreign keys: {}", e.message);
            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(),
@@ -1045,23 +929,7 @@ impl DbManager {
        max_rows: usize,
        cancel: &CancellationToken,
    ) -> IdeResult<QueryResult> {
-        self.execute_from(id, statement, 0, max_rows, cancel, None).await
-    }
-
-    /// [`execute`](Self::execute), reading past the first `skip` rows without keeping
-    /// them: a later page of a result, where only that page is decoded and returned.
-    /// `schema` is a query console's active context: the connection that runs the
-    /// statement is put in it first, so unqualified names resolve there.
-    pub async fn execute_from(
-        &self,
-        id: &str,
-        statement: &str,
-        skip: usize,
-        max_rows: usize,
-        cancel: &CancellationToken,
-        schema: Option<&str>,
-    ) -> IdeResult<QueryResult> {
-        let r = self.run(id, statement, skip, max_rows, cancel, schema).await;
+        let r = self.run(id, statement, max_rows, cancel).await;
        let ran = match &r {
            Ok(_) => true,
            Err(e) => !matches!(e.kind, ErrorKind::Cancelled | ErrorKind::PermissionDenied),
@@ -1093,42 +961,10 @@ impl DbManager {
            .map_err(|e| IdeError::internal(e.to_string()))?
    }

-    /// The execution plan of `statement` (explained, not run), in the console's
-    /// active `schema` when it has one.
-    pub async fn explain(
-        &self,
-        id: &str,
-        statement: &str,
-        cancel: &CancellationToken,
-        schema: Option<&str>,
-    ) -> IdeResult<Vec<PlanNode>> {
+    /// The execution plan of `statement` (explained, not run).
+    pub async fn explain(&self, id: &str, statement: &str, cancel: &CancellationToken) -> IdeResult<Vec<PlanNode>> {
        let driver = self.pool(id).await?.driver();
-        if driver == DbDriver::Oracle {
-            // EXPLAIN PLAN writes PLAN_TABLE; the plan is read (and cleaned up) separately.
-            let plan_id = format!(
-                "OPENIDEA{}",
-                std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map_or(0, |d| d.subsec_nanos())
-            );
-            self.run(
-                id,
-                &format!(
-                    "EXPLAIN PLAN SET STATEMENT_ID = '{}' FOR {}",
-                    plan_id,
-                    statement.trim().trim_end_matches(';')
-                ),
-                0,
-                MAX_META_ROWS,
-                cancel,
-                schema,
-            )
-            .await?;
-            let result = self.run(id, &plan::oracle_plan_query(&plan_id), 0, MAX_META_ROWS, cancel, None).await?;
-            let nodes = plan::parse(driver, &result);
-            let _ = self.run(id, &plan::oracle_plan_cleanup(&plan_id), 0, 0, cancel, None).await;
-            return nodes;
-        }
-        let result =
-            self.run(id, &plan::explain_statement(driver, statement), 0, MAX_META_ROWS, cancel, schema).await?;
+        let result = self.run(id, &plan::explain_statement(driver, statement), MAX_META_ROWS, cancel).await?;
        plan::parse(driver, &result)
    }

@@ -1136,42 +972,22 @@ impl DbManager {
        &self,
        id: &str,
        statement: &str,
-        skip: usize,
        max_rows: usize,
        cancel: &CancellationToken,
-        schema: Option<&str>,
    ) -> IdeResult<QueryResult> {
        let pool = self.pool(id).await?;
        let session = self.sessions.lock().get(id).cloned();
        let Some(session) = session else {
-            if schema.is_none() {
-                return pool.execute_from(statement, skip, max_rows, cancel).await;
-            }
-            // Like `Pool::execute_from`, with the schema applied to the connection first.
-            let mut conn = Held::acquire(&pool).await?;
-            let r = match conn.apply_context(schema).await {
-                Ok(()) => conn.execute_from(&pool, statement, skip, max_rows, cancel).await,
-                Err(e) => Err(e),
-            };
-            if cancel.is_cancelled() {
-                conn.discard().await;
-                return Err(IdeError::cancelled());
-            }
-            return r;
+            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?;
-            conn.apply_context(schema).await?;
            conn.command(conn::begin_statement(pool.driver())).await?;
            *held = Some(conn);
        }
        let conn = held.as_mut().expect("opened above");
-        conn.apply_context(schema).await?;
-        let r = conn.execute_from(&pool, statement, skip, max_rows, cancel).await;
+        let r = conn.execute(&pool, statement, max_rows, cancel).await;
        if cancel.is_cancelled() {
            // The server rolls the transaction back with the connection.
            held.take().expect("opened above").discard().await;
@@ -1182,11 +998,8 @@ 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) -> IdeResult<()> {
+    pub async fn set_manual_commit(&self, id: &str, manual: bool) {
        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);
@@ -1194,24 +1007,15 @@ 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;
        let Some(mut conn) = held.take() else { return Ok(()) };
-        let result = async {
-            conn.command(if commit { "COMMIT" } else { "ROLLBACK" }).await?;
-            conn.restore_default().await
-        }
-        .await;
-        match result {
+        match conn.command(if commit { "COMMIT" } else { "ROLLBACK" }).await {
            Ok(()) => Ok(()),
            Err(e) => {
                conn.discard().await;
@@ -1248,9 +1052,6 @@ 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
@@ -1263,112 +1064,3 @@ impl DbManager {
        pool.transaction(&statements).await
    }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use ide_ssh::secrets::testing::files_containing;
-    use std::path::Path;
-
-    fn manager(dir: &Path) -> DbManager {
-        ide_ssh::secrets::testing::use_memory_store();
-        let data = dir.join("data");
-        let ssh = Arc::new(SshManager::new(data.join("ssh-passwords.json")));
-        DbManager::new(dir.join("project"), data.join("db-passwords.json"), data.join("db-history.json"), ssh)
-    }
-
-    #[tokio::test]
-    async fn saved_passwords_stay_off_disk() {
-        let tmp = tempfile::tempdir().unwrap();
-        manager(tmp.path()).set_password("s1", Some("hunter2-db".into()), true).await.unwrap();
-        manager(tmp.path()).set_ssh_secret("s1", Some("hunter2-tunnel".into()), true).await.unwrap();
-        assert_eq!(files_containing(tmp.path(), "hunter2-db"), Vec::<PathBuf>::new());
-        assert_eq!(files_containing(tmp.path(), "hunter2-tunnel"), Vec::<PathBuf>::new());
-        let reopened = manager(tmp.path());
-        assert_eq!(reopened.secret(&DataSource::default(), "s1".into(), true).await.as_deref(), Some("hunter2-db"));
-        assert_eq!(
-            reopened.secret(&DataSource::default(), secrets::ssh_key("s1"), true).await.as_deref(),
-            Some("hunter2-tunnel")
-        );
-    }
-
-    #[tokio::test]
-    async fn moves_plaintext_passwords_of_older_versions_off_disk() {
-        let tmp = tempfile::tempdir().unwrap();
-        let project = tmp.path().join("project").to_string_lossy().into_owned();
-        let legacy = serde_json::json!({ project: { "s1": "old-db-pw" }, "/other": { "s2": "other-pw" } });
-        std::fs::create_dir_all(tmp.path().join("data")).unwrap();
-        std::fs::write(tmp.path().join("data/db-passwords.json"), legacy.to_string()).unwrap();
-        let m = manager(tmp.path());
-        assert_eq!(m.secret(&DataSource::default(), "s1".into(), true).await.as_deref(), Some("old-db-pw"));
-        assert_eq!(files_containing(tmp.path(), "old-db-pw"), Vec::<PathBuf>::new());
-        assert_eq!(files_containing(tmp.path(), "other-pw"), Vec::<PathBuf>::new());
-        let other = SecretStore::new(tmp.path().join("data/db-passwords.json"), Path::new("/other"));
-        assert_eq!(other.get("s2").as_deref(), Some("other-pw"));
-    }
-
-    #[tokio::test]
-    async fn global_data_sources_are_shared_by_projects_with_their_passwords() {
-        ide_ssh::secrets::testing::use_memory_store();
-        let tmp = tempfile::tempdir().unwrap();
-        let (app, one, two) = (tmp.path().join("app"), tmp.path().join("one"), tmp.path().join("two"));
-        let manager = |root: &std::path::Path| {
-            let ssh = Arc::new(SshManager::new(app.join("ssh-passwords.json")));
-            DbManager::new(root.to_path_buf(), app.join("passwords.json"), app.join("history.json"), ssh)
-                .with_global_sources(app.clone())
-        };
-        let (a, b) = (manager(&one), manager(&two));
-        let source = |id: &str, global: bool| DataSource {
-            id: id.into(),
-            name: id.into(),
-            driver: DbDriver::Postgres,
-            save_password: true,
-            global,
-            ..Default::default()
-        };
-        a.save_sources(vec![source("local", false), source("shared", false)]).await.unwrap();
-        a.set_password("shared", Some("pw".into()), true).await.unwrap();
-        // Made global: listed in the other project too, with its saved password.
-        a.save_sources(vec![source("local", false), source("shared", true)]).await.unwrap();
-        let ids = |m: &DbManager| m.sources().unwrap().into_iter().map(|s| (s.id, s.global)).collect::<Vec<_>>();
-        assert_eq!(ids(&a), [("local".into(), false), ("shared".into(), true)]);
-        assert_eq!(ids(&b), [("shared".into(), true)]);
-        assert_eq!(b.password(&b.source("shared").unwrap()).await.as_deref(), Some("pw"));
-        let project_file = std::fs::read_to_string(one.join(".openidea/data-sources.toml")).unwrap();
-        assert!(!project_file.contains("shared") && !project_file.contains("global"), "{project_file}");
-        assert!(!std::fs::read_to_string(app.join("data-sources.toml")).unwrap().contains("global"));
-        // Made project-level again: gone from the other project, the password stays with it.
-        a.save_sources(vec![source("local", false), source("shared", false)]).await.unwrap();
-        assert!(b.sources().unwrap().is_empty());
-        assert_eq!(a.password(&a.source("shared").unwrap()).await.as_deref(), Some("pw"));
-    }
-
-    #[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();
-    }
-}
@@ -1,649 +0,0 @@
-//! Oracle connections through the synchronous `rust-oracle` driver (ODPI-C).
-//! The Oracle client library (Instant Client) is loaded once per process from
-//! the Options tab or `ORACLE_HOME`; every blocking call runs on the blocking
-//! pool, and cancelling a statement closes its connection.
-
-use crate::conn::{Cells, Fetched, ResultColumn, Setup, hex};
-use crate::source::{DataSource, DbDriver, DbTxMode};
-use bb8::ManageConnection;
-use ide_core::{CancellationToken, IdeError, IdeResult, error::ErrorKind};
-use oracle::sql_type::{Blob, Clob, OracleType};
-use std::io::Read;
-use std::path::PathBuf;
-use std::sync::Arc;
-use std::time::{Duration, Instant};
-use tokio::sync::mpsc;
-
-/// Characters of a LOB column shown in the grid; catalog text reads more.
-const MAX_GRID_LOB: u64 = 4096;
-const MAX_TEXT_LOB: u64 = 1 << 16;
-
-/// Everything a new connection needs, built once per pool.
-#[derive(Debug)]
-struct State {
-    user: String,
-    password: String,
-    /// EZConnect `//host:port/service`, a TNS descriptor or an alias.
-    connect: String,
-    init: Vec<String>,
-    auto_commit: bool,
-    read_only: bool,
-    statement_cache: Option<u32>,
-    timeout: Duration,
-}
-
-impl State {
-    fn of(source: &DataSource, password: Option<&str>, setup: &Setup) -> IdeResult<Self> {
-        let user = source.user.trim();
-        if user.is_empty() {
-            return Err(IdeError::invalid("Oracle data sources need a user name"));
-        }
-        Ok(Self {
-            user: user.to_owned(),
-            password: password.unwrap_or_default().to_owned(),
-            connect: connect_string(source),
-            init: setup.statements.clone(),
-            auto_commit: source.options.transaction != DbTxMode::Manual,
-            read_only: source.read_only,
-            statement_cache: setup.statement_cache.map(|n| n as u32),
-            timeout: setup.connect_timeout.unwrap_or(Duration::from_secs(30)),
-        })
-    }
-}
-
-/// `//host:port/service`; the database field may also hold a TNS descriptor or alias.
-fn connect_string(source: &DataSource) -> String {
-    let db = source.database.trim();
-    if db.starts_with('(') || db.contains('=') {
-        return db.to_owned();
-    }
-    let host = if source.host.trim().is_empty() { "localhost" } else { source.host.trim() };
-    let port = source.port.unwrap_or(1521);
-    if db.is_empty() { format!("//{host}:{port}") } else { format!("//{host}:{port}/{db}") }
-}
-
-/// The expanded Instant Client directory, `None` when the search path is used.
-fn client_dir(dir: &str) -> IdeResult<Option<String>> {
-    let dir = dir.trim();
-    if dir.is_empty() {
-        return Ok(None);
-    }
-    let expanded: PathBuf = ide_ssh::expand(dir);
-    if !expanded.is_dir() {
-        return Err(IdeError::invalid(format!("Oracle Instant Client directory not found: {}", expanded.display())));
-    }
-    Ok(Some(expanded.to_string_lossy().into_owned()))
-}
-
-/// Loads the Oracle client once per process; the first data source's directory wins.
-/// Failures are not cached: a corrected directory works without restarting.
-fn init_client(dir: &str) -> IdeResult<()> {
-    static LOADED: std::sync::Mutex<Option<String>> = std::sync::Mutex::new(None);
-    let dir = dir.trim();
-    let mut loaded = LOADED.lock().unwrap_or_else(|e| e.into_inner());
-    if let Some(used) = loaded.as_deref() {
-        if !dir.is_empty() && !used.is_empty() && used != dir {
-            tracing::warn!("Oracle client already loaded from {used}; ignoring {dir}");
-        }
-        return Ok(());
-    }
-    let mut params = oracle::InitParams::new();
-    if let Some(lib_dir) = client_dir(dir)? {
-        params
-            .oracle_client_lib_dir(lib_dir)
-            .map_err(|e| IdeError::invalid(format!("Oracle Instant Client directory: {e}")))?;
-    }
-    params.init().map_err(|e| {
-        let hint = if e.to_string().contains("DPI-1047") {
-            format!("{e} — set the Instant Client directory (Options tab) or ORACLE_HOME")
-        } else {
-            e.to_string()
-        };
-        IdeError::new(ErrorKind::Io, format!("Oracle client: {hint}"))
-    })?;
-    *loaded = Some(dir.to_owned());
-    Ok(())
-}
-
-/// `rust-oracle` errors are not `Sync`; the pool wants a shareable error.
-#[derive(Debug, Clone)]
-pub struct OracleError(Arc<oracle::Error>);
-
-impl OracleError {
-    fn new(e: oracle::Error) -> Self {
-        Self(Arc::new(e))
-    }
-
-    fn message(msg: impl Into<String>) -> Self {
-        Self::new(oracle::Error::new(oracle::ErrorKind::InvalidArgument, msg.into()))
-    }
-
-    fn into_ide(self) -> IdeError {
-        oracle_err(clone_db(&self.0))
-    }
-}
-
-/// Database errors (the interesting ones) rebuild cheaply for cloning.
-fn clone_db(e: &oracle::Error) -> oracle::Error {
-    match e.db_error() {
-        Some(db) => oracle::Error::new(oracle::ErrorKind::OciError, db.message().to_owned()),
-        None => message_error(&e.to_string()),
-    }
-}
-
-fn message_error(msg: &str) -> oracle::Error {
-    oracle::Error::new(oracle::ErrorKind::InvalidArgument, msg.to_owned())
-}
-
-/// Wrong or missing password: ORA-01017 / ORA-01005; unreachable server: ORA-12xxx / ORA-31xx.
-pub(crate) fn oracle_err(e: oracle::Error) -> IdeError {
-    let Some(db) = e.db_error() else {
-        return IdeError::new(ErrorKind::InvalidInput, e.to_string());
-    };
-    let msg = db.message().to_owned();
-    if msg.contains("DPI-1047") {
-        return IdeError::new(
-            ErrorKind::Io,
-            format!("{msg} — set the Instant Client directory (Options tab) or ORACLE_HOME"),
-        );
-    }
-    let code = db.code();
-    let full = format!("[ORA-{code:05}] {msg}");
-    match code {
-        1005 | 1017 | 28000 | 28001 => IdeError::new(ErrorKind::PermissionDenied, full),
-        12150..=12199 | 12537 | 12540 | 12541 | 12543 | 12545 | 3113 | 3114 => IdeError::new(ErrorKind::Io, full),
-        _ => IdeError::new(ErrorKind::InvalidInput, full),
-    }
-}
-
-#[derive(Debug)]
-pub struct OraclePool {
-    state: Arc<State>,
-    pool: Arc<bb8::Pool<OracleConnectionManager>>,
-}
-
-impl OraclePool {
-    pub(crate) async fn connect(source: &DataSource, password: Option<&str>, setup: &Setup) -> IdeResult<Self> {
-        init_client(&source.options.instant_client)?;
-        let state = Arc::new(State::of(source, password, setup)?);
-        let pool = bb8::Pool::builder()
-            .max_size(4)
-            .connection_timeout(state.timeout)
-            .build(OracleConnectionManager(state.clone()))
-            .await
-            .map_err(|e| e.into_ide())?;
-        // bb8 connects lazily and reports failed attempts as a bare timeout, which
-        // would turn a wrong password into "timed out connecting to the database".
-        let opened = tokio::task::spawn_blocking({
-            let state = state.clone();
-            move || open(&state)
-        })
-        .await
-        .map_err(|e| IdeError::internal(format!("Oracle connect task: {e}")))?
-        .map_err(oracle_err)?;
-        let _ = pool.add(opened);
-        Ok(Self { state, pool: Arc::new(pool) })
-    }
-
-    /// A connection taken out of the pool for one statement or a held session.
-    pub async fn get(&self) -> IdeResult<OracleConnection> {
-        let pooled = self.pool.get_owned().await.map_err(|e| pool_err(e).into_ide())?;
-        Ok(OracleConnection { state: self.state.clone(), pooled })
-    }
-
-    pub fn is_closed(&self) -> bool {
-        let state = self.pool.state();
-        state.connections == 0 && state.idle_connections == 0
-    }
-}
-
-fn pool_err(e: bb8::RunError<OracleError>) -> OracleError {
-    match e {
-        bb8::RunError::User(e) => e,
-        bb8::RunError::TimedOut => OracleError::message("timed out connecting to the database"),
-    }
-}
-
-/// A pooled connection's payload; `conn` is `None` once the connection is
-/// discarded (a cancelled statement leaves it in the blocking task).
-pub struct OracleHandle {
-    conn: Option<oracle::Connection>,
-    context: crate::conn::Context,
-}
-
-pub struct OracleConnectionManager(Arc<State>);
-
-impl ManageConnection for OracleConnectionManager {
-    type Connection = OracleHandle;
-    type Error = OracleError;
-
-    async fn connect(&self) -> Result<Self::Connection, Self::Error> {
-        let state = self.0.clone();
-        let opened = tokio::task::spawn_blocking(move || open(&state))
-            .await
-            .map_err(|e| OracleError::message(format!("Oracle connect task: {e}")))?;
-        let conn = opened.map_err(OracleError::new)?;
-        Ok(conn)
-    }
-
-    async fn is_valid(&self, conn: &mut Self::Connection) -> Result<(), Self::Error> {
-        let state = self.0.clone();
-        let Some(raw) = conn.conn.take() else {
-            return Err(OracleError::message("Oracle connection is closed"));
-        };
-        let ping = tokio::time::timeout(
-            state.timeout,
-            tokio::task::spawn_blocking(move || {
-                let result = (|| -> oracle::Result<()> {
-                    // `execute` rejects selects, so read one row.
-                    let mut stmt = raw.statement("SELECT 1 FROM DUAL").build()?;
-                    let mut rows = stmt.query(&[])?;
-                    if let Some(row) = rows.next() {
-                        row?;
-                    }
-                    Ok(())
-                })();
-                (raw, result)
-            }),
-        )
-        .await;
-        match ping {
-            Ok(Ok((raw, Ok(())))) => {
-                conn.conn = Some(raw);
-                Ok(())
-            }
-            Ok(Ok((_, Err(e)))) => Err(OracleError::new(e)),
-            Ok(Err(e)) => Err(OracleError::message(format!("Oracle ping task: {e}"))),
-            // Timed out (the task keeps the connection and closes it): discard this one.
-            Err(_) => Err(OracleError::message("timed out waiting for the Oracle server")),
-        }
-    }
-
-    fn has_broken(&self, conn: &mut Self::Connection) -> bool {
-        conn.conn.is_none()
-    }
-}
-
-/// A connection borrowed from the pool. It returns to the pool when dropped,
-/// unless its statement was cancelled (then it is discarded).
-pub struct OracleConnection {
-    state: Arc<State>,
-    pooled: bb8::PooledConnection<'static, OracleConnectionManager>,
-}
-
-impl OracleConnection {
-    pub(crate) fn context(&mut self) -> &mut crate::conn::Context {
-        &mut self.pooled.context
-    }
-
-    pub fn is_closed(&self) -> bool {
-        self.pooled.conn.is_none()
-    }
-
-    /// Drops the connection instead of returning it; the server rolls an open
-    /// transaction back.
-    pub(crate) fn discard_inner(&mut self) {
-        self.pooled.conn.take();
-    }
-}
-
-fn open(state: &State) -> oracle::Result<OracleHandle> {
-    let mut connector = oracle::Connector::new(state.user.clone(), state.password.clone(), state.connect.clone());
-    connector.driver_name("OpenIDEA");
-    if let Some(n) = state.statement_cache {
-        connector.stmt_cache_size(n);
-    }
-    let mut conn = connector.connect()?;
-    conn.set_autocommit(state.auto_commit);
-    for sql in &state.init {
-        statement(&mut conn, sql, 0, 0, Cells::Text).map_err(|e| message_error(&e.message))?;
-    }
-    let user: String = conn.query_row_as("SELECT SYS_CONTEXT('USERENV', 'SESSION_USER') FROM DUAL", &[])?;
-    let default = crate::sql::use_schema(DbDriver::Oracle, &user);
-    let current: String = conn.query_row_as("SELECT SYS_CONTEXT('USERENV', 'CURRENT_SCHEMA') FROM DUAL", &[])?;
-    let mut context = crate::conn::Context::new(default);
-    context.set_current(crate::sql::use_schema(DbDriver::Oracle, &current));
-    Ok(OracleHandle { conn: Some(conn), context })
-}
-
-/// Runs `f` with the connection on the blocking pool. Cancelling drops the
-/// connection instead of returning it (its statement keeps running server-side).
-async fn with_conn<T>(
-    c: &mut OracleConnection,
-    cancel: &CancellationToken,
-    f: impl FnOnce(&mut oracle::Connection) -> IdeResult<T> + Send + 'static,
-) -> IdeResult<T>
-where
-    T: Send + 'static,
-{
-    let Some(conn) = c.pooled.conn.take() else {
-        return Err(IdeError::new(ErrorKind::Io, "Oracle connection is closed"));
-    };
-    let (tx, mut rx) = mpsc::channel::<(oracle::Connection, IdeResult<T>)>(1);
-    tokio::task::spawn_blocking(move || {
-        let mut slot = Some(conn);
-        let result = match slot.as_mut() {
-            Some(conn) => f(conn),
-            None => unreachable!("connection taken above"),
-        };
-        // A closed receiver (cancelled) drops the connection, closing it.
-        let _ = tx.blocking_send((slot.take().expect("some"), result));
-    });
-    tokio::select! {
-        item = rx.recv() => match item {
-            Some((conn, result)) => {
-                c.pooled.conn = Some(conn);
-                result
-            }
-            None => Err(IdeError::internal("the Oracle connection task failed")),
-        },
-        () = cancel.cancelled() => {
-            rx.close();
-            Err(IdeError::cancelled())
-        }
-    }
-}
-
-/// Runs a script on `c` (see [`crate::conn::Pool::rows`] and `Held::execute`).
-pub(crate) async fn run(
-    c: &mut OracleConnection,
-    sql: &str,
-    skip: usize,
-    max: usize,
-    mode: Cells,
-    cancel: &CancellationToken,
-) -> IdeResult<Fetched> {
-    let state = c.state.clone();
-    let sql = sql.to_owned();
-    with_conn(c, cancel, move |conn| statements(conn, &state, &sql, skip, max, mode)).await
-}
-
-/// The table editor's edits in one transaction.
-pub(crate) async fn transaction(c: &mut OracleConnection, statements: &[(String, bool)]) -> IdeResult<u64> {
-    if c.state.read_only {
-        return Err(IdeError::new(ErrorKind::PermissionDenied, "read-only connection: edits are not allowed"));
-    }
-    let script = statements.iter().map(|(sql, _)| sql.clone()).collect::<Vec<_>>();
-    let expect: Vec<bool> = statements.iter().map(|(_, e)| *e).collect();
-    let apply = move |conn: &mut oracle::Connection| -> IdeResult<u64> {
-        conn.set_autocommit(false);
-        let mut total = 0;
-        for (sql, expect_one) in script.iter().zip(&expect) {
-            let mut stmt = conn.statement(sql).build().map_err(oracle_err)?;
-            stmt.execute(&[]).map_err(oracle_err)?;
-            let n = stmt.row_count().map_err(oracle_err)?;
-            if *expect_one && n != 1 {
-                conn.rollback().ok();
-                return Err(IdeError::invalid(format!(
-                    "{sql}: expected to change 1 row, changed {n}; nothing was saved"
-                )));
-            }
-            total += n;
-        }
-        conn.commit().map_err(oracle_err)?;
-        Ok(total)
-    };
-    let cancel = CancellationToken::new();
-    with_conn(c, &cancel, apply).await
-}
-
-/// Runs every statement of `sql` (one script, PL/SQL blocks kept whole): the
-/// first query's rows are the result, otherwise the total rows changed.
-fn statements(
-    conn: &mut oracle::Connection,
-    state: &State,
-    sql: &str,
-    skip: usize,
-    max: usize,
-    mode: Cells,
-) -> IdeResult<Fetched> {
-    conn.set_autocommit(state.auto_commit);
-    let mut query: Option<Fetched> = None;
-    let mut affected: u64 = 0;
-    let mut first: Option<Instant> = None;
-    for s in crate::split::split(sql, DbDriver::Oracle) {
-        if state.read_only && is_write(&s.text) {
-            return Err(IdeError::new(
-                ErrorKind::PermissionDenied,
-                format!("read-only connection: {} statements are not allowed", first_word(&s.text)),
-            ));
-        }
-        let r = statement(conn, &s.text, skip, max, mode)?;
-        first.get_or_insert_with(|| r.4.unwrap_or_else(Instant::now));
-        if r.0.is_empty() {
-            affected += r.2.unwrap_or(0);
-        } else if query.is_none() {
-            query = Some(r);
-        }
-    }
-    Ok(query.unwrap_or((Vec::new(), Vec::new(), Some(affected), false, first)))
-}
-
-/// Reads one statement; `skip` rows are fetched and dropped (result pagination).
-fn statement(conn: &mut oracle::Connection, sql: &str, skip: usize, max: usize, mode: Cells) -> IdeResult<Fetched> {
-    let started = Instant::now();
-    // LOB locators let `cell` read only the shown prefix (the default fetches whole LOBs).
-    let mut stmt = conn
-        .statement(sql)
-        .fetch_array_size((max as u32).clamp(1, 1000) + 1)
-        .lob_locator()
-        .build()
-        .map_err(oracle_err)?;
-    match stmt.statement_type() {
-        oracle::StatementType::Select => {
-            let rows = stmt.query(&[]).map_err(oracle_err)?;
-            let columns: Vec<ResultColumn> = rows
-                .column_info()
-                .iter()
-                .map(|c| ResultColumn { name: c.name().to_owned(), type_name: c.oracle_type().to_string() })
-                .collect();
-            let mut out: Vec<Vec<Option<String>>> = Vec::new();
-            let mut has_more = false;
-            let mut to_skip = skip;
-            for row in rows {
-                if to_skip > 0 {
-                    to_skip -= 1;
-                    continue;
-                }
-                if out.len() >= max {
-                    has_more = true;
-                    break;
-                }
-                let row = row.map_err(oracle_err)?;
-                out.push(row.sql_values().iter().map(|v| cell(v, mode)).collect());
-            }
-            Ok((columns, out, None, has_more, Some(started)))
-        }
-        _ => {
-            stmt.execute(&[]).map_err(oracle_err)?;
-            let affected = stmt.row_count().map_err(oracle_err)?;
-            Ok((Vec::new(), Vec::new(), Some(affected), false, Some(started)))
-        }
-    }
-}
-
-fn first_word(sql: &str) -> String {
-    sql.lines()
-        .map(str::trim)
-        .find(|l| !l.is_empty() && !l.starts_with("--"))
-        .and_then(|l| l.split_whitespace().next())
-        .unwrap_or("")
-        .to_ascii_uppercase()
-}
-
-/// Whether `sql` changes data or schema (read-only connections refuse it).
-fn is_write(sql: &str) -> bool {
-    !matches!(first_word(sql).as_str(), "SELECT" | "WITH" | "SHOW" | "EXPLAIN" | "DESCRIBE" | "DESC" | "SET")
-}
-
-fn cell(v: &oracle::SqlValue, mode: Cells) -> Option<String> {
-    if v.is_null().unwrap_or(false) {
-        return None;
-    }
-    match v.oracle_type().ok() {
-        Some(OracleType::CLOB | OracleType::NCLOB) => {
-            let lob: Clob = v.get().ok()?;
-            let cap = if mode == Cells::Text { MAX_TEXT_LOB } else { MAX_GRID_LOB };
-            let mut s = String::new();
-            lob.take(cap).read_to_string(&mut s).ok()?;
-            Some(s)
-        }
-        Some(OracleType::BLOB) => {
-            let lob: Blob = v.get().ok()?;
-            let cap = if mode == Cells::Text { MAX_TEXT_LOB } else { MAX_GRID_LOB };
-            let mut buf = Vec::new();
-            lob.take(cap).read_to_end(&mut buf).ok()?;
-            Some(hex(&buf))
-        }
-        _ => v.get::<String>().ok(),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn connect_strings() {
-        let s = |db: &str| DataSource {
-            driver: DbDriver::Oracle,
-            host: "db.local".into(),
-            port: Some(1521),
-            database: db.into(),
-            ..Default::default()
-        };
-        assert_eq!(connect_string(&s("ORCLPDB1")), "//db.local:1521/ORCLPDB1");
-        assert_eq!(connect_string(&s("")), "//db.local:1521");
-        assert_eq!(
-            connect_string(&DataSource { host: String::new(), port: None, database: "ORCL".into(), ..s("") }),
-            "//localhost:1521/ORCL"
-        );
-        assert_eq!(connect_string(&s("(DESCRIPTION=(ADDRESS=...))")), "(DESCRIPTION=(ADDRESS=...))");
-        assert_eq!(connect_string(&s("PROD=MYDB")), "PROD=MYDB");
-    }
-
-    #[test]
-    fn write_detection() {
-        assert!(!is_write("SELECT 1 FROM DUAL"));
-        assert!(!is_write("-- x\nWITH q AS (SELECT 1) SELECT * FROM q"));
-        assert!(!is_write("DESC users"));
-        assert!(is_write("INSERT INTO t VALUES (1)"));
-        assert!(is_write("begin\n  null;\nend;"));
-        assert!(is_write("DROP TABLE t"));
-    }
-
-    #[test]
-    fn missing_user_is_rejected_before_connecting() {
-        let setup = Setup::default();
-        let err = State::of(&DataSource { driver: DbDriver::Oracle, ..Default::default() }, None, &setup).unwrap_err();
-        assert!(err.message.contains("user name"));
-        let state = State::of(
-            &DataSource { driver: DbDriver::Oracle, user: "scott".into(), ..Default::default() },
-            Some("tiger"),
-            &setup,
-        )
-        .unwrap();
-        assert_eq!(
-            (state.user.as_str(), state.password.as_str(), state.connect.as_str()),
-            ("scott", "tiger", "//localhost:1521")
-        );
-        assert!(state.auto_commit);
-    }
-
-    #[test]
-    fn oracle_errors_map_to_kinds() {
-        let auth = oracle_err(message_error("x")).kind; // no database error: invalid input
-        assert_eq!(auth, ErrorKind::InvalidInput);
-    }
-
-    #[tokio::test]
-    async fn a_discarded_connection_is_broken_but_a_live_one_is_not() {
-        // No server is reachable here, so the pooled connection is a husk: `has_broken`
-        // decides whether bb8 keeps it, which is what cancellation relies on.
-        let manager = OracleConnectionManager(Arc::new(
-            State::of(
-                &DataSource { driver: DbDriver::Oracle, user: "scott".into(), ..Default::default() },
-                None,
-                &Setup::default(),
-            )
-            .unwrap(),
-        ));
-        let mut broken = OracleHandle { conn: None, context: crate::conn::Context::new(None) };
-        assert!(manager.has_broken(&mut broken));
-        // A connection that cannot be opened reports the failure without panicking
-        // (a client-load error, or ORA-12541 when a client is available).
-        match manager.connect().await {
-            Ok(_) => unreachable!("no server is listening"),
-            Err(err) => assert!(!err.into_ide().message.is_empty()),
-        }
-    }
-
-    #[test]
-    fn connect_reports_a_missing_client_directory() {
-        let err = client_dir("/nonexistent/instantclient").expect_err("no such directory");
-        assert!(err.message.contains("Instant Client directory not found"), "{}", err.message);
-        assert!(client_dir("").expect("the search path").is_none());
-    }
-
-    /// A live server, skipped unless `OPENIDEA_ORACLE_TEST` is
-    /// `user/password@host:port/service` (and `OPENIDEA_ORACLE_CLIENT` names the
-    /// Instant Client when it is not on the search path).
-    ///
-    /// Checking out a connection runs `is_valid`, so this fails if the ping is
-    /// not a query (bb8 silently retries a rejected check-out until it times out).
-    #[tokio::test]
-    async fn a_pooled_connection_runs_queries() {
-        let Some(spec) = std::env::var("OPENIDEA_ORACLE_TEST").ok().filter(|s| !s.is_empty()) else { return };
-        let (auth, addr) = spec.split_once('@').expect("user/password@host:port/service");
-        let (user, password) = auth.split_once('/').expect("user/password");
-        let (host, rest) = addr.split_once(':').expect("host:port/service");
-        let (port, service) = rest.split_once('/').expect("port/service");
-        let source = DataSource {
-            driver: DbDriver::Oracle,
-            host: host.into(),
-            port: Some(port.parse().expect("port")),
-            database: service.into(),
-            user: user.into(),
-            options: crate::source::DbOptions {
-                instant_client: std::env::var("OPENIDEA_ORACLE_CLIENT").unwrap_or_default(),
-                ..Default::default()
-            },
-            ..Default::default()
-        };
-        // A missing or wrong password asks for one (the UI prompts on PermissionDenied).
-        for wrong in [None, Some("wrong")] {
-            let Err(err) = crate::conn::Pool::connect(&source, wrong, None).await else { panic!("bad password") };
-            assert_eq!(err.kind, ErrorKind::PermissionDenied, "{}", err.message);
-        }
-        let pool = crate::conn::Pool::connect(&source, Some(password), None).await.expect("connect");
-        let rows = pool.rows("SELECT 1 FROM DUAL", 1).await.expect("query through the pool");
-        assert_eq!(rows.first().and_then(|r| r.first().cloned().flatten()).as_deref(), Some("1"));
-
-        // The result grid reads later pages by skipping rows client-side.
-        let page = pool
-            .execute_from("SELECT LEVEL FROM DUAL CONNECT BY LEVEL <= 10", 4, 3, &CancellationToken::new())
-            .await
-            .expect("second page");
-        let values: Vec<String> = page.rows.iter().filter_map(|r| r.first().cloned().flatten()).collect();
-        assert_eq!(values, ["5", "6", "7"]);
-        assert!(page.has_more);
-
-        // PL/SQL units reach the server with their closing `END;`.
-        pool.rows("begin null; end;", 0).await.expect("anonymous block");
-        pool.rows("declare n number := 1; begin n := n + 1; end;", 0).await.expect("declare block");
-        let proc = "create or replace procedure openidea_p(a number) is\n  x number := a;\nbegin\n  x := x + 1;\nend;";
-        let rows = pool.rows(&format!("{proc}\nselect 7 from dual;"), 1).await.expect("procedure, then a query");
-        assert_eq!(rows.first().and_then(|r| r.first().cloned().flatten()).as_deref(), Some("7"));
-        pool.rows("begin openidea_p(1); end;", 0).await.expect("call the procedure");
-        let package = "create or replace package openidea_k as\n  function f return number;\nend openidea_k;\n/\n\
-                       create or replace package body openidea_k as\n  function f return number is begin return 8; end;\nend openidea_k;\n/";
-        pool.rows(package, 0).await.expect("package spec and body");
-        let rows = pool.rows("select openidea_k.f from dual", 1).await.expect("call the package");
-        assert_eq!(rows.first().and_then(|r| r.first().cloned().flatten()).as_deref(), Some("8"));
-        pool.rows("drop package openidea_k; drop procedure openidea_p", 0).await.expect("clean up");
-
-        // LOB cells are read through locators.
-        let rows = pool.rows("select to_clob('abc'), to_blob(hextoraw('0A0B')) from dual", 1).await.expect("LOBs");
-        assert_eq!(rows.first().cloned(), Some(vec![Some("abc".into()), Some("0x0A0B".into())]));
-    }
-}
@@ -35,32 +35,16 @@ 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}"),
-        DbDriver::Oracle => format!("EXPLAIN PLAN FOR {s}"),
    }
 }

-/// Reads the plan `EXPLAIN PLAN SET STATEMENT_ID = '{plan_id}'` wrote (see [`parse`] with `DbDriver::Oracle`).
-pub fn oracle_plan_query(plan_id: &str) -> String {
-    format!(
-        "SELECT id, parent_id, operation, options, object_name, cost, cardinality, bytes \
-         FROM plan_table WHERE statement_id = '{plan_id}' ORDER BY id"
-    )
-}
-
-/// Removes a read plan (PLAN_TABLE keeps rows until the session ends).
-pub fn oracle_plan_cleanup(plan_id: &str) -> String {
-    format!("DELETE FROM plan_table WHERE statement_id = '{plan_id}'")
-}
-
 /// Reads the result of [`explain_statement`].
 pub fn parse(driver: DbDriver, result: &QueryResult) -> IdeResult<Vec<PlanNode>> {
    match driver {
        DbDriver::Sqlite => Ok(sqlite(&result.rows)),
-        DbDriver::Oracle => Ok(oracle(&result.rows)),
-        DbDriver::Postgres | DbDriver::Clickhouse => {
+        DbDriver::Postgres => {
            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}")))?;
@@ -163,40 +147,6 @@ fn postgres(node: &Value, parent: Option<u32>, out: &mut Vec<PlanNode>) {
    }
 }

-/// Oracle PLAN_TABLE rows: `id, parent_id, operation, options, object_name, cost, cardinality, bytes`.
-fn oracle(rows: &[Vec<Option<String>>]) -> Vec<PlanNode> {
-    let mut ids: Vec<String> = Vec::new();
-    let mut out = Vec::new();
-    for r in rows {
-        let cell = |i: usize| r.get(i).cloned().flatten().unwrap_or_default();
-        let (id, parent, operation, options, object) = (cell(0), cell(1), cell(2), cell(3), cell(4));
-        let parent = ids.iter().position(|x| *x == parent).map(|i| i as u32);
-        let op = format!("{operation} {options}").trim().to_owned();
-        let (operation, params) = match (operation.as_str(), options.as_str()) {
-            ("TABLE ACCESS", "FULL") => ("Full Scan".into(), object),
-            ("TABLE ACCESS", "BY INDEX ROWID" | "BY ROWID RANGE" | "BY USER ROWID") => ("Table Access".into(), object),
-            ("INDEX", "RANGE SCAN" | "RANGE SCAN DESCENDING") => ("Index Range Scan".into(), object),
-            ("INDEX", "UNIQUE SCAN") => ("Index Lookup".into(), object),
-            ("INDEX", "FULL SCAN" | "FAST FULL SCAN" | "SKIP SCAN") => ("Full Index Scan".into(), object),
-            ("INDEX", "SAMPLE FAST FULL SCAN") => ("Full Index Scan".into(), object),
-            ("SORT", "ORDER BY") => ("Order By".into(), String::new()),
-            ("SORT", "GROUP BY") => ("Group By".into(), String::new()),
-            ("SORT", "UNIQUE") => ("Distinct".into(), String::new()),
-            ("HASH", "GROUP BY") => ("Group By".into(), String::new()),
-            _ => (op, object),
-        };
-        let mut properties = Vec::new();
-        for (name, value) in [("Cost", 5), ("Rows", 6), ("Bytes", 7)] {
-            if let Some(v) = r.get(value).cloned().flatten() {
-                properties.push(prop(name, v));
-            }
-        }
-        out.push(PlanNode { parent, operation, params, properties });
-        ids.push(id);
-    }
-    out
-}
-
 /// MySQL's tabular `EXPLAIN`: one row per table access, flat.
 fn mysql(names: &[&str], rows: &[Vec<Option<String>>]) -> Vec<PlanNode> {
    let col = |r: &[Option<String>], n: &str| {
@@ -249,51 +199,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");
-        assert_eq!(explain_statement(DbDriver::Oracle, "select 1"), "EXPLAIN PLAN FOR select 1");
-        let q = oracle_plan_query("OI1");
-        assert!(q.contains("FROM plan_table WHERE statement_id = 'OI1' ORDER BY id"));
-        assert!(oracle_plan_cleanup("OI1").contains("DELETE FROM plan_table WHERE statement_id = 'OI1'"));
-    }
-
-    #[test]
-    fn reads_oracle_plan_table_rows() {
-        let r = result(
-            &["id", "parent_id", "operation", "options", "object_name", "cost", "cardinality", "bytes"],
-            vec![
-                vec![Some("1"), Some("0"), Some("SELECT STATEMENT"), None, None, Some("3"), Some("41"), Some("1230")],
-                vec![Some("2"), Some("1"), Some("HASH"), Some("GROUP BY"), None, Some("3"), Some("41"), Some("1230")],
-                vec![
-                    Some("4"),
-                    Some("2"),
-                    Some("TABLE ACCESS"),
-                    Some("FULL"),
-                    Some("orders"),
-                    Some("2"),
-                    Some("41"),
-                    Some("1230"),
-                ],
-                vec![
-                    Some("5"),
-                    Some("2"),
-                    Some("INDEX"),
-                    Some("UNIQUE SCAN"),
-                    Some("c_pk"),
-                    Some("0"),
-                    Some("1"),
-                    Some("6"),
-                ],
-            ],
-        );
-        let plan = parse(DbDriver::Oracle, &r).unwrap();
-        let ops: Vec<(&str, &str)> = plan.iter().map(|n| (n.operation.as_str(), n.params.as_str())).collect();
-        assert_eq!(
-            ops,
-            [("SELECT STATEMENT", ""), ("Group By", ""), ("Full Scan", "orders"), ("Index Lookup", "c_pk")]
-        );
-        assert_eq!((plan[2].parent, plan[3].parent), (Some(1), Some(1)));
-        assert!(plan[0].properties.iter().any(|p| p.name == "Cost" && p.value == "3"));
    }

    #[test]
@@ -348,21 +254,6 @@ 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(
@@ -1,15 +1,20 @@
-//! Saved data source passwords, in the OS credential store like the other saved
-//! passwords ([`SecretFile`]). One index file for all projects; each credential is
-//! keyed by project root, then credential key.
+//! Saved data source passwords, in the app's data directory rather than the OS
+//! credential store (no system prompts). One JSON file for all projects, keyed
+//! by project root, then credential key; owner-only on Unix.

-use ide_core::IdeResult;
-use ide_ssh::secrets::SecretFile;
+use ide_core::{IdeError, IdeResult};
+use parking_lot::Mutex;
 use std::collections::BTreeMap;
 use std::path::{Path, PathBuf};

+/// Project root → credential key → secret.
+type Contents = BTreeMap<String, BTreeMap<String, String>>;
+
+/// Serialises read-modify-write across the projects sharing the file.
+static LOCK: Mutex<()> = Mutex::new(());
+
 pub struct SecretStore {
    path: PathBuf,
-    file: SecretFile,
    project: String,
 }

@@ -18,41 +23,61 @@ pub fn ssh_key(id: &str) -> String {
    format!("{id}#ssh")
 }

-fn file_key(project: &str, key: &str) -> String {
-    format!("{project}|{key}")
-}
-
-/// Older versions' file: project root → credential key → secret.
-fn legacy(value: serde_json::Value) -> Option<BTreeMap<String, String>> {
-    let all: BTreeMap<String, BTreeMap<String, String>> = serde_json::from_value(value).ok()?;
-    Some(
-        all.into_iter()
-            .flat_map(|(project, keys)| keys.into_iter().map(move |(k, s)| (file_key(&project, &k), s)))
-            .collect(),
-    )
-}
-
 impl SecretStore {
    pub fn new(path: PathBuf, root: &Path) -> Self {
-        let file = SecretFile::with_legacy(path.clone(), legacy);
-        Self { path, file, project: root.to_string_lossy().into_owned() }
-    }
-
-    /// The same file, keyed by `scope` instead (global data sources: the app data directory).
-    pub fn scoped(&self, scope: &Path) -> Self {
-        Self::new(self.path.clone(), scope)
+        Self { path, project: root.to_string_lossy().into_owned() }
    }

    pub fn get(&self, key: &str) -> Option<String> {
-        self.file.get(&file_key(&self.project, key))
+        let _g = LOCK.lock();
+        self.read().remove(&self.project)?.remove(key)
    }

    pub fn set(&self, key: &str, secret: &str) -> IdeResult<()> {
-        self.file.set(&file_key(&self.project, key), secret)
+        let _g = LOCK.lock();
+        let mut all = self.read();
+        all.entry(self.project.clone()).or_default().insert(key.to_owned(), secret.to_owned());
+        self.write(&all)
    }

    pub fn delete(&self, key: &str) {
-        self.file.delete(&file_key(&self.project, key))
+        let _g = LOCK.lock();
+        let mut all = self.read();
+        let Some(project) = all.get_mut(&self.project) else { return };
+        if project.remove(key).is_none() {
+            return;
+        }
+        if project.is_empty() {
+            all.remove(&self.project);
+        }
+        if let Err(e) = self.write(&all) {
+            tracing::warn!("saved passwords: {}", e.message);
+        }
+    }
+
+    fn read(&self) -> Contents {
+        match std::fs::read(&self.path) {
+            Ok(bytes) => serde_json::from_slice(&bytes).unwrap_or_else(|e| {
+                tracing::warn!("saved passwords: {}: {e}", self.path.display());
+                Contents::new()
+            }),
+            Err(_) => Contents::new(),
+        }
+    }
+
+    fn write(&self, all: &Contents) -> IdeResult<()> {
+        let err = |e: std::io::Error| IdeError::unavailable(format!("saved passwords: {e}"));
+        if let Some(dir) = self.path.parent() {
+            std::fs::create_dir_all(dir).map_err(err)?;
+        }
+        let tmp = self.path.with_extension("json.tmp");
+        let mut options = std::fs::OpenOptions::new();
+        options.write(true).create(true).truncate(true);
+        #[cfg(unix)]
+        std::os::unix::fs::OpenOptionsExt::mode(&mut options, 0o600);
+        let bytes = serde_json::to_vec_pretty(all).map_err(|e| IdeError::internal(e.to_string()))?;
+        std::io::Write::write_all(&mut options.open(&tmp).map_err(err)?, &bytes).map_err(err)?;
+        std::fs::rename(&tmp, &self.path).map_err(err)
    }
 }

@@ -62,7 +87,6 @@ mod tests {

    #[test]
    fn keeps_projects_apart_and_drops_empty_ones() {
-        ide_ssh::secrets::testing::use_memory_store();
        let tmp = tempfile::tempdir().unwrap();
        let file = tmp.path().join("db-passwords.json");
        let a = SecretStore::new(file.clone(), Path::new("/p/a"));
@@ -1,7 +1,6 @@
-//! Data sources: per-project connection settings in `.openidea/data-sources.toml`, and
-//! global ones (IDEA's Make Global: listed in every project) in `data-sources.toml` of the
-//! app data directory. Passwords never go there: saved ones live in [`crate::secrets`],
-//! the others only in memory for the session.
+//! Data sources: per-project connection settings in `.openidea/data-sources.toml`.
+//! Passwords never go there: saved ones live in [`crate::secrets`], the others
+//! only in memory for the session.

 use ide_core::{IdeError, IdeResult, IpcPath, project_dir};
 use serde::{Deserialize, Serialize};
@@ -19,9 +18,6 @@ pub enum DbDriver {
    Mysql,
    /// Microsoft SQL Server.
    SqlServer,
-    Clickhouse,
-    /// Oracle Database (via Oracle Instant Client).
-    Oracle,
 }

 impl DbDriver {
@@ -31,8 +27,6 @@ impl DbDriver {
            DbDriver::Postgres => Some(5432),
            DbDriver::Mysql => Some(3306),
            DbDriver::SqlServer => Some(1433),
-            DbDriver::Clickhouse => Some(8123),
-            DbDriver::Oracle => Some(1521),
        }
    }
 }
@@ -88,8 +82,6 @@ pub struct DbOptions {
    pub auto_disconnect_secs: Option<u32>,
    /// PostgreSQL: show only the configured database, its schemas right under the data source.
    pub single_database: bool,
-    /// Oracle: directory of the Oracle Instant Client (empty: `ORACLE_HOME` / system search path).
-    pub instant_client: String,
 }

 /// Schemas tab: the databases / schemas the tree shows. Names may use `*` and `?`.
@@ -187,9 +179,6 @@ pub struct DataSource {
    pub options: DbOptions,
    pub introspection: DbIntrospection,
    pub properties: Vec<DbProperty>,
-    /// Stored app-wide and listed in every project. Implied by the file it is read from,
-    /// so not written to it.
-    pub global: bool,
 }

 impl Default for DataSource {
@@ -218,7 +207,6 @@ impl Default for DataSource {
            options: DbOptions::default(),
            introspection: DbIntrospection::default(),
            properties: Vec::new(),
-            global: false,
        }
    }
 }
@@ -265,8 +253,6 @@ 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),
-        "oracle" | "oracledb" => Some(DbDriver::Oracle),
        _ => None,
    }
 }
@@ -274,17 +260,11 @@ 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("invalid database URL");
+    let bad = || IdeError::invalid(format!("not a database URL: {raw}"));
    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)?;
    let driver = scheme_driver(scheme).ok_or_else(bad)?;
-    // JDBC thin URLs: `jdbc:oracle:thin:@//host:port/service` (after the `jdbc:` prefix).
-    let rest = if driver == DbDriver::Oracle {
-        rest.strip_prefix("thin:@").or_else(|| rest.strip_prefix("thin:/@")).unwrap_or(rest)
-    } else {
-        rest
-    };
    if driver == DbDriver::Sqlite {
        let file = rest.strip_prefix("//").unwrap_or(rest);
        let file = file.split('?').next().unwrap_or_default();
@@ -387,15 +367,6 @@ 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)
    }

@@ -414,32 +385,9 @@ struct SourcesFile {
    sources: Vec<DataSource>,
 }

-/// The project's data sources.
 pub fn load(root: &Path) -> IdeResult<Vec<DataSource>> {
-    read(&project_dir::path(root, FILE))
-}
-
-/// Saves the project's data sources.
-pub fn save(root: &Path, sources: &[DataSource]) -> IdeResult<()> {
-    write(&project_dir::path(root, FILE), sources)
-}
-
-/// The global data sources stored in `dir` (the app data directory).
-pub fn load_global(dir: &Path) -> IdeResult<Vec<DataSource>> {
-    let mut sources = read(&dir.join(FILE))?;
-    for s in &mut sources {
-        s.global = true;
-    }
-    Ok(sources)
-}
-
-/// Saves the global data sources in `dir`.
-pub fn save_global(dir: &Path, sources: &[DataSource]) -> IdeResult<()> {
-    write(&dir.join(FILE), sources)
-}
-
-fn read(path: &Path) -> IdeResult<Vec<DataSource>> {
-    let text = match std::fs::read_to_string(path) {
+    let path = project_dir::path(root, FILE);
+    let text = match std::fs::read_to_string(&path) {
        Ok(t) => t,
        Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(Vec::new()),
        Err(e) => return Err(e.into()),
@@ -448,23 +396,19 @@ fn read(path: &Path) -> IdeResult<Vec<DataSource>> {
    Ok(file.sources)
 }

-fn write(path: &Path, sources: &[DataSource]) -> IdeResult<()> {
+pub fn save(root: &Path, sources: &[DataSource]) -> IdeResult<()> {
    for s in sources {
        if s.id.is_empty() || s.name.trim().is_empty() {
            return Err(IdeError::invalid("every data source needs an id and a name"));
        }
    }
+    let path = project_dir::path(root, FILE);
    if let Some(dir) = path.parent() {
        std::fs::create_dir_all(dir)?;
    }
-    let internal = |e: &dyn std::fmt::Display| IdeError::internal(e.to_string());
-    let mut value = toml::Value::try_from(SourcesFile { sources: sources.to_vec() }).map_err(|e| internal(&e))?;
-    if let Some(list) = value.get_mut("data-source").and_then(toml::Value::as_array_mut) {
-        for table in list.iter_mut().filter_map(toml::Value::as_table_mut) {
-            table.remove("global");
-        }
-    }
-    std::fs::write(path, toml::to_string_pretty(&value).map_err(|e| internal(&e))?)?;
+    let text = toml::to_string_pretty(&SourcesFile { sources: sources.to_vec() })
+        .map_err(|e| IdeError::internal(e.to_string()))?;
+    std::fs::write(path, text)?;
    Ok(())
 }

@@ -552,11 +496,7 @@ mod tests {
        assert_eq!(parse_url("jdbc:redshift://r:5439/dev").unwrap().driver, Some(DbDriver::Postgres));
        assert_eq!(parse_url("tidb://h:4000").unwrap().driver, Some(DbDriver::Mysql));
        assert_eq!(parse_url("sqlite:/tmp/a.db").unwrap().file.as_deref(), Some("/tmp/a.db"));
-        let u = parse_url("oracle://scott:[email protected]:1521/ORCLPDB1").unwrap();
-        assert_eq!(u.driver, Some(DbDriver::Oracle));
-        assert_eq!((u.host.as_str(), u.port, u.database.as_str()), ("db.local", Some(1521), "ORCLPDB1"));
-        assert_eq!((u.user.as_str(), u.password.as_deref()), ("scott", Some("tiger")));
-        assert_eq!(parse_url("oracledb://[email protected]/hrdb").unwrap().driver, Some(DbDriver::Oracle));
+        assert!(parse_url("oracle://x").is_err());
        assert!(parse_url("postgres://h:99999/db").is_err());
    }

@@ -579,31 +519,4 @@ 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"));
-    }
 }
@@ -9,8 +9,7 @@ use specta::Type;
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct SqlStatement {
-    /// UTF-16 offsets of the statement text (whitespace trimmed, `;` excluded except
-    /// after an Oracle PL/SQL block, whose `END;` needs it).
+    /// UTF-16 offsets of the statement text (whitespace trimmed, `;` excluded).
    pub from: u32,
    pub to: u32,
    pub text: String,
@@ -29,9 +28,6 @@ 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;
-    // PL/SQL: `;` inside BEGIN…END / DECLARE…END blocks does not terminate a statement.
-    let plsql = driver == DbDriver::Oracle;
    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);
@@ -49,14 +45,6 @@ pub fn split(text: &str, driver: DbDriver) -> Vec<SqlStatement> {
    // Whether the current segment has anything but whitespace / comments.
    let mut has_code = false;
    let mut i = 0usize;
-    // PL/SQL block depth (BEGIN / CASE / LOOP open, END closes).
-    let mut depth = 0usize;
-    // Inside a top-level block's declaration section (`DECLARE … BEGIN`).
-    let mut declarations = false;
-    // The segment is a PL/SQL block: its closing `;` is part of the statement.
-    let mut block = false;
-    // `CREATE PACKAGE` / `TYPE BODY`: only `/` on its own line (or the end) ends it.
-    let mut package = false;
    let push = |out: &mut Vec<SqlStatement>, s: usize, e: usize, has_code: bool| {
        if !has_code {
            return;
@@ -80,24 +68,11 @@ pub fn split(text: &str, driver: DbDriver) -> Vec<SqlStatement> {
        let next = chars.get(i + 1).map(|c| c.1);
        match state {
            State::Code => match c {
-                _ if plsql && !has_code && c.is_alphabetic() => {
-                    match plsql_unit(&chars, i) {
-                        Unit::Sql => {}
-                        Unit::Block => block = true,
-                        Unit::Subprogram => (block, declarations) = (true, true),
-                        Unit::Package => (block, package) = (true, true),
-                    }
-                    has_code = true;
-                    // Re-read this character as code (it may start BEGIN / DECLARE).
-                    continue;
-                }
-                ';' if depth == 0 && !declarations && !package => {
-                    push(&mut out, start, if block { i + 1 } else { i }, has_code);
+                ';' => {
+                    push(&mut out, start, i, has_code);
                    start = i + 1;
                    has_code = false;
-                    block = false;
                }
-                ';' => has_code = true,
                '\'' => {
                    state = State::Single;
                    has_code = true;
@@ -106,32 +81,19 @@ pub fn split(text: &str, driver: DbDriver) -> Vec<SqlStatement> {
                    state = State::Double;
                    has_code = true;
                }
-                '`' if mysql || clickhouse => {
+                '`' if mysql => {
                    state = State::Backtick;
                    has_code = true;
                }
-                '/' if next == Some('*') => {
-                    state = State::BlockComment;
-                    i += 1;
-                }
-                '/' if plsql && ends_line(&chars, i) && starts_line(&chars, i) => {
-                    // SQL*Plus block terminator: `/` alone on its line ends the statement.
-                    push(&mut out, start, i, has_code);
-                    while chars.get(i).is_some_and(|&(_, c)| c != '\n') {
-                        i += 1;
-                    }
-                    start = i + 1;
-                    has_code = false;
-                    depth = 0;
-                    declarations = false;
-                    block = false;
-                    package = false;
-                }
                '-' if next == Some('-') => {
                    state = State::LineComment;
                    i += 1;
                }
                '#' if mysql => state = State::LineComment,
+                '/' if next == Some('*') => {
+                    state = State::BlockComment;
+                    i += 1;
+                }
                '$' if driver == DbDriver::Postgres => {
                    // `$tag$ … $tag$` (tag may be empty); `$1` parameters are not quotes.
                    let rest = &text[byte_at(i)..];
@@ -151,39 +113,11 @@ pub fn split(text: &str, driver: DbDriver) -> Vec<SqlStatement> {
                        continue;
                    }
                }
-                _ if plsql && word_at(&chars, i, "BEGIN") => {
-                    depth += 1;
-                    declarations = false;
-                    has_code = true;
-                }
-                _ if plsql && word_at(&chars, i, "CASE") || plsql && word_at(&chars, i, "LOOP") => {
-                    depth += 1;
-                    has_code = true;
-                }
-                // `DECLARE … BEGIN … END;` is one block: the declarations of a top-level block
-                // end at BEGIN, so their `;` must not split it.
-                _ if plsql && word_at(&chars, i, "DECLARE") => {
-                    if depth == 0 {
-                        declarations = true;
-                    }
-                    has_code = true;
-                }
-                _ if plsql && word_at(&chars, i, "END") => {
-                    // `END IF` closes an IF (which never opened a block); END LOOP / END CASE
-                    // close the block their keyword opened. Other ENDs close a block.
-                    let after = skip_ws(&chars, i + 3);
-                    let closing = ["LOOP", "CASE", "IF"].into_iter().find(|w| word_at(&chars, after, w));
-                    if closing != Some("IF") && depth > 0 {
-                        depth -= 1;
-                    }
-                    i = closing.map_or(i + 3, |w| after + w.len()) - 1;
-                    has_code = true;
-                }
                c if !c.is_whitespace() => has_code = true,
                _ => {}
            },
            State::Single => {
-                if (mysql || clickhouse) && c == '\\' {
+                if mysql && c == '\\' {
                    i += 1;
                } else if c == '\'' {
                    if next == Some('\'') {
@@ -194,9 +128,7 @@ pub fn split(text: &str, driver: DbDriver) -> Vec<SqlStatement> {
                }
            }
            State::Double => {
-                if clickhouse && c == '\\' {
-                    i += 1;
-                } else if c == '"' {
+                if c == '"' {
                    if next == Some('"') {
                        i += 1;
                    } else {
@@ -205,9 +137,7 @@ pub fn split(text: &str, driver: DbDriver) -> Vec<SqlStatement> {
                }
            }
            State::Backtick => {
-                if clickhouse && (c == '\\' || (c == '`' && next == Some('`'))) {
-                    i += 1;
-                } else if c == '`' {
+                if c == '`' {
                    state = State::Code;
                }
            }
@@ -229,73 +159,6 @@ pub fn split(text: &str, driver: DbDriver) -> Vec<SqlStatement> {
    out
 }

-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-enum Unit {
-    Sql,
-    /// `DECLARE` / `BEGIN`: an anonymous block.
-    Block,
-    /// `CREATE PROCEDURE` / `FUNCTION` / `TRIGGER`: declarations up to the body's BEGIN.
-    Subprogram,
-    /// `CREATE PACKAGE [BODY]` / `TYPE BODY`.
-    Package,
-}
-
-/// What kind of PL/SQL unit, if any, a statement starting at `i` is.
-fn plsql_unit(chars: &[(usize, char)], mut i: usize) -> Unit {
-    let mut words: Vec<String> = Vec::new();
-    while words.len() < 6 {
-        let word: String = chars[i.min(chars.len())..]
-            .iter()
-            .map(|&(_, c)| c)
-            .take_while(|c| c.is_alphanumeric() || *c == '_' || *c == '$')
-            .collect();
-        if word.is_empty() {
-            break;
-        }
-        i = skip_ws(chars, i + word.chars().count());
-        words.push(word.to_ascii_uppercase());
-    }
-    let w = |n: usize| words.get(n).map_or("", String::as_str);
-    match w(0) {
-        "DECLARE" | "BEGIN" => return Unit::Block,
-        "CREATE" => {}
-        _ => return Unit::Sql,
-    }
-    let mut n = if (w(1), w(2)) == ("OR", "REPLACE") { 3 } else { 1 };
-    if matches!(w(n), "EDITIONABLE" | "NONEDITIONABLE") {
-        n += 1;
-    }
-    match (w(n), w(n + 1)) {
-        ("PROCEDURE" | "FUNCTION" | "TRIGGER", _) => Unit::Subprogram,
-        ("PACKAGE", _) | ("TYPE", "BODY") => Unit::Package,
-        _ => Unit::Sql,
-    }
-}
-
-/// Whether the characters at `i` are the keyword `word` (identifier bounds respected).
-fn word_at(chars: &[(usize, char)], i: usize, word: &str) -> bool {
-    let (before, after) = (chars[..i].last().map(|&(_, c)| c), chars.get(i).map(|&(_, c)| c));
-    before.is_none_or(|c| !c.is_alphanumeric() && c != '_' && c != '$')
-        && after.is_some_and(|c| c.is_ascii_alphabetic())
-        && chars[i..].iter().take(word.len()).map(|&(_, c)| c.to_ascii_uppercase()).eq(word.chars())
-        && chars.get(i + word.len()).is_none_or(|&(_, c)| !c.is_alphanumeric() && c != '_' && c != '$')
-}
-
-/// Whether only whitespace follows `i` until the end of its line.
-fn ends_line(chars: &[(usize, char)], i: usize) -> bool {
-    chars[i + 1..].iter().take_while(|&&(_, c)| c != '\n').all(|&(_, c)| c.is_whitespace())
-}
-
-/// Whether only whitespace precedes `i` since the start of its line.
-fn starts_line(chars: &[(usize, char)], i: usize) -> bool {
-    chars[..i].iter().rev().take_while(|&&(_, c)| c != '\n').all(|&(_, c)| c.is_whitespace())
-}
-
-/// The index of the first non-whitespace character at or after `i`.
-fn skip_ws(chars: &[(usize, char)], i: usize) -> usize {
-    chars[i..].iter().position(|&(_, c)| !c.is_whitespace()).map_or(chars.len(), |n| i + n)
-}
-
 /// The statement to run for a caret at `offset` (UTF-16): the one containing
 /// it, else the nearest one before it (caret after `;` or on a blank line
 /// below), else the next one.
@@ -361,12 +224,6 @@ 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 =
@@ -409,62 +266,4 @@ mod tests {
        assert_eq!(s.iter().map(|s| s.text.as_str()).collect::<Vec<_>>(), vec!["select 1", "select 2"]);
        assert_eq!((s[1].from, s[1].to), (13, 21));
    }
-
-    #[test]
-    fn oracle_keeps_plsql_blocks_as_one_statement() {
-        let block = "begin\n  for r in (select 1 from dual) loop\n    null; -- ;\n  end loop;\nend";
-        assert_eq!(
-            texts(&format!("{block};\nselect 2;"), DbDriver::Oracle),
-            vec![format!("{block};"), "select 2".into()]
-        );
-        let nested = "declare\n  x number;\nbegin\n  if x = 1 then\n    case when x = 2 then\n      null;\n    end case;\n    begin\n      null;\n    end;\n  end if;\nend";
-        assert_eq!(
-            texts(&format!("{nested};\nselect 3;"), DbDriver::Oracle),
-            vec![format!("{nested};"), "select 3".into()]
-        );
-        // Plain SQL with CASE is unaffected; END IF does not close a block twice.
-        assert_eq!(
-            texts("select case when a = 1 then 2 end from t; select 2", DbDriver::Oracle),
-            vec!["select case when a = 1 then 2 end from t", "select 2"]
-        );
-    }
-
-    #[test]
-    fn oracle_slash_terminator_and_other_drivers_unaffected() {
-        // `END;` ends the block; a following `/` (SQL*Plus's own terminator) adds nothing.
-        assert_eq!(
-            texts("begin\n  null;\nend;\n/\nselect 2", DbDriver::Oracle),
-            vec!["begin\n  null;\nend;", "select 2"]
-        );
-        // A division is not a terminator.
-        assert_eq!(texts("select 1 /\n 2 from dual", DbDriver::Oracle), vec!["select 1 /\n 2 from dual"]);
-        assert_eq!(texts("select 'a;b' from t; select 2", DbDriver::Oracle), vec!["select 'a;b' from t", "select 2"]);
-    }
-
-    #[test]
-    fn oracle_create_units_keep_their_declarations_and_end() {
-        let proc = "create or replace procedure p(a number) is\n  x number := 1;\nbegin\n  null;\nend p;";
-        assert_eq!(texts(&format!("{proc}\nselect 1 from dual;"), DbDriver::Oracle), vec![proc, "select 1 from dual"]);
-        let trigger =
-            "CREATE TRIGGER t BEFORE INSERT ON x FOR EACH ROW\nDECLARE n NUMBER;\nBEGIN\n  :new.id := 1;\nEND;";
-        assert_eq!(
-            texts(&format!("{trigger}\nselect 2 from dual"), DbDriver::Oracle),
-            vec![trigger, "select 2 from dual"]
-        );
-        // Packages end at `/` (or the end of the script), like in SQL*Plus.
-        let spec = "create package k as\n  procedure a;\n  function f return number;\nend k;";
-        let body = "create package body k as\n  procedure a is begin null; end;\n  function f return number is begin return 1; end;\nbegin\n  null;\nend k;";
-        assert_eq!(
-            texts(&format!("{spec}\n/\n{body}\n/\nselect 3 from dual;"), DbDriver::Oracle),
-            vec![spec, body, "select 3 from dual"]
-        );
-        // Other CREATE statements and object types stay plain SQL.
-        assert_eq!(
-            texts(
-                "create view v as select 1 x from dual; create type t as object (a number); select 4",
-                DbDriver::Oracle
-            ),
-            vec!["create view v as select 1 x from dual", "create type t as object (a number)", "select 4"]
-        );
-    }
 }
@@ -7,7 +7,6 @@ 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('"', "\"\"")),
@@ -16,7 +15,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 matches!(driver, DbDriver::Mysql | DbDriver::Clickhouse) {
+    if driver == DbDriver::Mysql {
        s = s.replace('\\', "\\\\");
    }
    format!("'{s}'")
@@ -46,47 +45,15 @@ pub fn databases(templates: bool) -> &'static str {
 /// Databases of managed services that their users cannot use (hidden unless connected to).
 pub const INTERNAL_DATABASES: &[&str] = &["rdsadmin", "azure_maintenance", "azure_sys", "cloudsqladmin"];

-/// Oracle system accounts hidden unless `show_system` (see the Schemas tab).
-pub const ORACLE_SYSTEM_SCHEMAS: &[&str] = &[
-    "CTXSYS",
-    "DBSFWUSER",
-    "DVSYS",
-    "GSMADMIN_INTERNAL",
-    "LBACSYS",
-    "MDDATA",
-    "MDSYS",
-    "OLAPSYS",
-    "OUTLN",
-    "SYS",
-    "SYSTEM",
-    "XDB",
-    "XS$NULL",
-];
-
-/// Databases available to this login; offline/restoring databases cannot be selected.
-pub fn sqlserver_databases() -> &'static str {
-    "SELECT name FROM sys.databases WHERE state = 0 AND HAS_DBACCESS(name) = 1 ORDER BY name"
-}
-
 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"
        }
        DbDriver::Mysql if system => "SELECT schema_name FROM information_schema.schemata ORDER BY 1",
        DbDriver::SqlServer if system => "SELECT schema_name FROM information_schema.schemata ORDER BY 1",
-        DbDriver::Oracle if system => "SELECT username FROM all_users ORDER BY username",
-        DbDriver::Oracle => {
-            "SELECT username FROM all_users WHERE username NOT IN \
-             ('CTXSYS', 'DBSFWUSER', 'DVSYS', 'GSMADMIN_INTERNAL', 'LBACSYS', 'MDDATA', 'MDSYS', 'OLAPSYS', \
-             'OUTLN', 'SYS', 'SYSTEM', 'XDB', 'XS$NULL') ORDER BY username"
-        }
        DbDriver::Postgres => {
            "SELECT schema_name FROM information_schema.schemata \
             WHERE schema_name NOT IN ('pg_catalog', 'information_schema') \
@@ -106,23 +73,11 @@ 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",
            quote_ident(driver, schema)
        ),
-        DbDriver::Oracle => format!(
-            "SELECT table_name, 'table' FROM all_tables WHERE owner = {} \
-             UNION ALL SELECT view_name, 'view' FROM all_views WHERE owner = {} ORDER BY 1",
-            quote_literal(driver, schema),
-            quote_literal(driver, schema)
-        ),
        DbDriver::Postgres => format!(
            "SELECT c.relname, CASE c.relkind WHEN 'v' THEN 'view' WHEN 'm' THEN 'materialized view' ELSE 'table' END \
             FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace \
@@ -146,12 +101,6 @@ 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"
@@ -182,17 +131,6 @@ pub fn columns(driver: DbDriver, schema: &str, table: &str) -> String {
             FROM information_schema.columns c WHERE c.table_schema = {s} AND c.table_name = {t} \
             ORDER BY c.ordinal_position"
        ),
-        DbDriver::Oracle => format!(
-            "SELECT c.column_name, c.data_type, DECODE(c.nullable, 'Y', 'YES', 'NO'), c.data_default, \
-             CASE WHEN k.column_name IS NOT NULL THEN 1 ELSE 0 END \
-             FROM all_tab_columns c \
-             LEFT JOIN (SELECT kc.column_name FROM all_constraints con \
-               JOIN all_cons_columns kc ON kc.owner = con.owner AND kc.table_name = con.table_name \
-               AND kc.constraint_name = con.constraint_name \
-               WHERE con.constraint_type = 'P' AND con.owner = {s} AND con.table_name = {t}) k \
-             ON k.column_name = c.column_name \
-             WHERE c.owner = {s} AND c.table_name = {t} ORDER BY c.column_id"
-        ),
    }
 }

@@ -200,12 +138,6 @@ 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"
@@ -230,12 +162,6 @@ pub fn indexes(driver: DbDriver, schema: &str, table: &str) -> String {
             WHERE OBJECT_SCHEMA_NAME(i.object_id) = {s} AND OBJECT_NAME(i.object_id) = {t} AND i.name IS NOT NULL \
             ORDER BY i.name, ic.key_ordinal"
        ),
-        DbDriver::Oracle => format!(
-            "SELECT i.index_name, CASE WHEN i.uniqueness = 'UNIQUE' THEN 1 ELSE 0 END, ic.column_name \
-             FROM all_indexes i JOIN all_ind_columns ic \
-             ON ic.index_owner = i.owner AND ic.index_name = i.index_name \
-             WHERE i.owner = {s} AND i.table_name = {t} ORDER BY i.index_name, ic.column_position"
-        ),
    }
 }

@@ -243,15 +169,6 @@ 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, \
@@ -296,21 +213,6 @@ pub fn completion_columns(driver: DbDriver) -> &'static str {
             WHERE c.table_schema NOT IN ('sys', 'information_schema') \
             ORDER BY c.table_schema, c.table_name, c.ordinal_position"
        }
-        DbDriver::Oracle => {
-            "SELECT c.owner, c.table_name, CASE WHEN v.view_name IS NOT NULL THEN 'view' ELSE 'table' END, \
-             c.column_name, c.data_type, DECODE(c.nullable, 'Y', 'YES', 'NO'), \
-             CASE WHEN k.column_name IS NOT NULL THEN 1 ELSE 0 END, \
-             CASE WHEN c.data_default IS NOT NULL THEN 1 ELSE 0 END \
-             FROM all_tab_columns c \
-             LEFT JOIN all_views v ON v.owner = c.owner AND v.view_name = c.table_name \
-             LEFT JOIN (SELECT con.owner, con.table_name, kc.column_name FROM all_constraints con \
-               JOIN all_cons_columns kc ON kc.owner = con.owner AND kc.table_name = con.table_name \
-               AND kc.constraint_name = con.constraint_name WHERE con.constraint_type = 'P') k \
-             ON k.owner = c.owner AND k.table_name = c.table_name AND k.column_name = c.column_name \
-             WHERE c.owner NOT IN ('CTXSYS', 'DBSFWUSER', 'DVSYS', 'GSMADMIN_INTERNAL', 'LBACSYS', 'MDDATA', \
-             'MDSYS', 'OLAPSYS', 'OUTLN', 'SYS', 'SYSTEM', 'XDB', 'XS$NULL') \
-             ORDER BY c.owner, c.table_name, c.column_id FETCH FIRST 50000 ROWS ONLY"
-        }
    }
 }

@@ -319,7 +221,6 @@ 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 \
@@ -350,19 +251,6 @@ pub fn foreign_keys(driver: DbDriver) -> &'static str {
             AND table_schema NOT IN ('sys', 'information_schema') \
             ORDER BY table_schema, table_name, constraint_name, ordinal_position"
        }
-        DbDriver::Oracle => {
-            "SELECT con.owner, con.table_name, con.constraint_name, col.column_name, \
-             rcon.owner, rcon.table_name, rcol.column_name \
-             FROM all_constraints con \
-             JOIN all_cons_columns col ON col.owner = con.owner AND col.table_name = con.table_name \
-             AND col.constraint_name = con.constraint_name \
-             JOIN all_constraints rcon ON rcon.owner = con.r_owner AND rcon.constraint_name = con.r_constraint_name \
-             JOIN all_cons_columns rcol ON rcol.owner = rcon.owner AND rcol.table_name = rcon.table_name \
-             AND rcol.constraint_name = rcon.constraint_name \
-             WHERE con.constraint_type = 'R' AND con.owner NOT IN ('CTXSYS', 'DBSFWUSER', 'DVSYS', \
-             'GSMADMIN_INTERNAL', 'LBACSYS', 'MDDATA', 'MDSYS', 'OLAPSYS', 'OUTLN', 'SYS', 'SYSTEM', 'XDB', 'XS$NULL') \
-             ORDER BY 1, 2, 3, col.position FETCH FIRST 20000 ROWS ONLY"
-        }
    }
 }

@@ -370,7 +258,6 @@ 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"
        ),
@@ -383,33 +270,16 @@ pub fn table_foreign_keys(driver: DbDriver, schema: &str, table: &str) -> String
        DbDriver::SqlServer => format!(
            "SELECT table_schema, table_name, constraint_name, column_name,              referenced_table_schema, referenced_table_name, referenced_column_name              FROM information_schema.key_column_usage WHERE referenced_table_name IS NOT NULL              AND table_schema = {s} AND table_name = {t} ORDER BY constraint_name, ordinal_position"
        ),
-        DbDriver::Oracle => format!(
-            "SELECT con.owner, con.table_name, con.constraint_name, col.column_name,              rcon.owner, rcon.table_name, rcol.column_name              FROM all_constraints con              JOIN all_cons_columns col ON col.owner = con.owner AND col.table_name = con.table_name              AND col.constraint_name = con.constraint_name              JOIN all_constraints rcon ON rcon.owner = con.r_owner AND rcon.constraint_name = con.r_constraint_name              JOIN all_cons_columns rcol ON rcol.owner = rcon.owner AND rcol.table_name = rcon.table_name              AND rcol.constraint_name = rcon.constraint_name              WHERE con.constraint_type = 'R' AND con.owner = {s} AND con.table_name = {t}              ORDER BY con.constraint_name, col.position"
-        ),
    }
 }

 /// 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()"),
        DbDriver::SqlServer => Some("SELECT DB_NAME()"),
-        DbDriver::Oracle => Some("SELECT SYS_CONTEXT('USERENV', 'CURRENT_SCHEMA') FROM DUAL"),
-    }
-}
-
-/// The statement that makes unqualified names resolve in `schema` on the
-/// connection that runs it (a query console's active schema; `None`: the driver
-/// has no schema to switch — SQLite's `main`, ClickHouse's `USE` differs).
-pub fn use_schema(driver: DbDriver, schema: &str) -> Option<String> {
-    match driver {
-        DbDriver::Sqlite | DbDriver::Clickhouse => None,
-        DbDriver::Postgres => Some(format!("SET search_path TO {}", quote_ident(driver, schema))),
-        DbDriver::Mysql | DbDriver::SqlServer => Some(format!("USE {}", quote_ident(driver, schema))),
-        DbDriver::Oracle => Some(format!("ALTER SESSION SET CURRENT_SCHEMA = {}", quote_ident(driver, schema))),
    }
 }

@@ -454,8 +324,6 @@ pub fn table_page(
            sql.push_str(" ORDER BY (SELECT 1)");
        }
        sql.push_str(&format!(" OFFSET {offset} ROWS FETCH NEXT {} ROWS ONLY", limit + 1));
-    } else if driver == DbDriver::Oracle {
-        sql.push_str(&format!(" OFFSET {offset} ROWS FETCH FIRST {} ROWS ONLY", limit + 1));
    } else {
        sql.push_str(&format!(" LIMIT {} OFFSET {offset}", limit + 1));
    }
@@ -494,9 +362,6 @@ 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 } => {
@@ -518,8 +383,6 @@ pub fn edit_statement(driver: DbDriver, schema: &str, table: &str, edit: &DbRowE
            if values.is_empty() {
                return Ok(match driver {
                    DbDriver::Mysql => format!("INSERT INTO {target} () VALUES ()"),
-                    // Oracle has no DEFAULT VALUES; without columns there is nothing to insert.
-                    DbDriver::Oracle => return Err("Oracle needs at least one column value to insert".into()),
                    _ => format!("INSERT INTO {target} DEFAULT VALUES"),
                });
            }
@@ -587,7 +450,6 @@ 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)
@@ -608,12 +470,6 @@ pub fn triggers(driver: DbDriver, schema: &str, table: &str) -> String {
            "SELECT t.name, lower(te.type_desc), '' FROM sys.triggers t \
             WHERE OBJECT_SCHEMA_NAME(t.parent_id) = {s} AND OBJECT_NAME(t.parent_id) = {t} ORDER BY 1"
        ),
-        DbDriver::Oracle => format!(
-            "SELECT trigger_name, CASE WHEN trigger_type LIKE 'BEFORE%' THEN 'before' \
-             WHEN trigger_type LIKE 'INSTEAD%' THEN 'instead of' ELSE 'after' END, \
-             lower(replace(triggering_event, ' OR ', ',')) \
-             FROM all_triggers WHERE owner = {s} AND table_name = {t} ORDER BY 1"
-        ),
    }
 }

@@ -636,7 +492,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 | DbDriver::Clickhouse => None,
+        DbDriver::Sqlite => 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, \
@@ -656,28 +512,17 @@ pub fn routines(driver: DbDriver, schema: &str) -> Option<String> {
            "SELECT r.routine_name, lower(r.routine_type), '', r.data_type \
             FROM information_schema.routines r WHERE r.routine_schema = {s} ORDER BY 1"
        )),
-        DbDriver::Oracle => Some(format!(
-            "SELECT object_name, CASE object_type WHEN 'PROCEDURE' THEN 'procedure' ELSE 'function' END, '', NULL \
-             FROM all_objects WHERE owner = {s} AND object_type IN ('PROCEDURE', 'FUNCTION') \
-             AND object_name NOT LIKE 'BIN$%' ORDER BY 1"
-        )),
    }
 }

-/// Rows: `name, data type` of a schema's sequences (PostgreSQL, Oracle).
+/// Rows: `name, data type` of a schema's sequences (PostgreSQL).
 pub fn sequences(driver: DbDriver, schema: &str) -> Option<String> {
-    match driver {
-        DbDriver::Postgres => Some(format!(
+    (driver == DbDriver::Postgres).then(|| {
+        format!(
            "SELECT sequence_name, data_type FROM information_schema.sequences WHERE sequence_schema = {} ORDER BY 1",
            quote_literal(driver, schema)
-        )),
-        // Every sequence is numeric; ALL_SEQUENCES has no data_type column before 18c.
-        DbDriver::Oracle => Some(format!(
-            "SELECT sequence_name, 'NUMBER' FROM all_sequences WHERE sequence_owner = {} ORDER BY 1",
-            quote_literal(driver, schema)
-        )),
-        _ => None,
-    }
+        )
+    })
 }

 /// The statement reading the definition of a routine (a row per overload), trigger
@@ -722,26 +567,6 @@ pub fn object_ddl(driver: DbDriver, schema: &str, kind: crate::DbObjectKind, nam
        (DbDriver::Mysql, K::Function) => (format!("SHOW CREATE FUNCTION {target}"), 2),
        (DbDriver::Mysql, K::Procedure) => (format!("SHOW CREATE PROCEDURE {target}"), 2),
        (DbDriver::Mysql, K::Trigger) => (format!("SHOW CREATE TRIGGER {target}"), 2),
-        (DbDriver::Oracle, K::Function | K::Procedure | K::Trigger) => (
-            format!(
-                "SELECT DBMS_METADATA.GET_DDL('{}', {n}, {s}) FROM DUAL",
-                match kind {
-                    K::Function => "FUNCTION",
-                    K::Procedure => "PROCEDURE",
-                    _ => "TRIGGER",
-                }
-            ),
-            0,
-        ),
-        (DbDriver::Oracle, K::Sequence) => (
-            format!(
-                "SELECT 'create sequence ' || {n} || E'\\n    increment by ' || increment_by || \
-                 E'\\n    minvalue ' || min_value || E'\\n    maxvalue ' || max_value || \
-                 E'\\n    start with ' || last_number || CASE WHEN cycle_flag = 'Y' THEN E'\\n    cycle' ELSE '' END \
-                 FROM all_sequences WHERE sequence_owner = {s} AND sequence_name = {n}"
-            ),
-            0,
-        ),
        _ => return None,
    })
 }
@@ -800,71 +625,6 @@ 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 }];
@@ -928,64 +688,6 @@ mod tests {
        assert!(completion_columns(DbDriver::SqlServer).contains("information_schema.columns"));
    }

-    #[test]
-    fn oracle_quoting_pages_and_current_schema() {
-        assert_eq!(quote_ident(DbDriver::Oracle, "a\"b"), "\"a\"\"b\"");
-        assert_eq!(quote_literal(DbDriver::Oracle, "it's"), "'it''s'");
-        assert_eq!(qualified(DbDriver::Oracle, "hr", "employees"), "\"hr\".\"employees\"");
-        assert_eq!(current_schema(DbDriver::Oracle), Some("SELECT SYS_CONTEXT('USERENV', 'CURRENT_SCHEMA') FROM DUAL"));
-        assert_eq!(crate::conn::begin_statement(DbDriver::Oracle), "");
-        let sort = [SortKey { column: "id".into(), descending: true }];
-        assert_eq!(
-            table_page(DbDriver::Oracle, "hr", "employees", Some("WHERE id > 3"), &sort, 50, 25),
-            "SELECT * FROM \"hr\".\"employees\" WHERE id > 3 ORDER BY \"id\" DESC OFFSET 50 ROWS FETCH FIRST 26 ROWS ONLY"
-        );
-        assert_eq!(
-            table_page(DbDriver::Oracle, "", "t", None, &[], 0, 10),
-            "SELECT * FROM \"t\" OFFSET 0 ROWS FETCH FIRST 11 ROWS ONLY"
-        );
-    }
-
-    #[test]
-    fn oracle_introspection_queries() {
-        assert_eq!(DbDriver::Oracle.default_port(), Some(1521));
-        assert!(schemas(DbDriver::Oracle, true).contains("all_users"));
-        assert!(schemas(DbDriver::Oracle, false).contains("'MDSYS'"));
-        assert!(tables(DbDriver::Oracle, "hr").contains("all_tables"));
-        assert!(tables(DbDriver::Oracle, "hr").contains("all_views"));
-        let cols = columns(DbDriver::Oracle, "hr", "employees");
-        assert!(cols.contains("all_tab_columns"));
-        assert!(cols.contains("DECODE(c.nullable, 'Y', 'YES', 'NO')"));
-        assert!(cols.contains("constraint_type = 'P'"));
-        assert!(indexes(DbDriver::Oracle, "hr", "t").contains("all_indexes"));
-        assert!(foreign_keys(DbDriver::Oracle).contains("constraint_type = 'R'"));
-        assert!(table_foreign_keys(DbDriver::Oracle, "hr", "t").contains("all_cons_columns"));
-        assert!(completion_columns(DbDriver::Oracle).contains("all_tab_columns"));
-        assert!(triggers(DbDriver::Oracle, "hr", "t").contains("all_triggers"));
-        assert!(routines(DbDriver::Oracle, "hr").unwrap().contains("all_objects"));
-        assert!(sequences(DbDriver::Oracle, "hr").unwrap().contains("all_sequences"));
-    }
-
-    #[test]
-    fn oracle_edits_and_object_ddl() {
-        let key = vec![cv("id", Some("1"))];
-        assert_eq!(
-            edit_statement(
-                DbDriver::Oracle,
-                "hr",
-                "t",
-                &DbRowEdit::Update { key: key.clone(), values: vec![cv("n", Some("x"))] }
-            )
-            .unwrap(),
-            "UPDATE \"hr\".\"t\" SET \"n\" = 'x' WHERE \"id\" = '1'"
-        );
-        assert!(edit_statement(DbDriver::Oracle, "hr", "t", &DbRowEdit::Insert { values: vec![] }).is_err());
-        use crate::DbObjectKind as K;
-        let (q, col) = object_ddl(DbDriver::Oracle, "hr", K::Procedure, "p").unwrap();
-        assert!(q.contains("DBMS_METADATA.GET_DDL('PROCEDURE'") && col == 0);
-        assert!(object_ddl(DbDriver::Oracle, "hr", K::Sequence, "q").unwrap().0.contains("all_sequences"));
-    }
-
    #[test]
    fn sqlite_trigger_events() {
        let ev = sqlite_trigger_event;
@@ -1011,20 +713,6 @@ mod tests {
        assert!(object_ddl(DbDriver::Postgres, "s", K::Sequence, "q").unwrap().0.contains("sequencename = 'q'"));
    }

-    #[test]
-    fn schema_switch_statement_per_dialect() {
-        assert_eq!(use_schema(DbDriver::Postgres, "app data"), Some("SET search_path TO \"app data\"".into()));
-        assert_eq!(use_schema(DbDriver::Mysql, "a`b"), Some("USE `a``b`".into()));
-        assert_eq!(use_schema(DbDriver::SqlServer, "app] data"), Some("USE [app]] data]".into()));
-        assert_eq!(use_schema(DbDriver::Postgres, "a\"b"), Some("SET search_path TO \"a\"\"b\"".into()));
-        assert_eq!(use_schema(DbDriver::Oracle, "a\"b"), Some("ALTER SESSION SET CURRENT_SCHEMA = \"a\"\"b\"".into()));
-        assert!(sqlserver_databases().contains("state = 0 AND HAS_DBACCESS(name) = 1"));
-        assert_eq!(use_schema(DbDriver::Oracle, "hr"), Some("ALTER SESSION SET CURRENT_SCHEMA = \"hr\"".into()));
-        // Single-schema (SQLite) and not-yet-supported drivers: no dropdown, no switch.
-        assert_eq!(use_schema(DbDriver::Sqlite, "main"), None);
-        assert_eq!(use_schema(DbDriver::Clickhouse, "default"), None);
-    }
-
    #[test]
    fn postgres_ddl() {
        let cols = [
@@ -1,136 +0,0 @@
-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, None).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(())
-}
@@ -85,101 +85,3 @@ async fn metadata_names_are_text_whatever_the_column_collation() -> IdeResult<()
    let raw = manager(&tmp, "SET character_set_results = binary").await.unwrap();
    assert_metadata_is_text(&raw).await
 }
-
-// A console's active schema: the connection that runs each autocommit statement
-// is put in it first, so unqualified names resolve there (and not elsewhere).
-// Its own schema names: tests of this file share one server but run in parallel.
-#[tokio::test]
-async fn active_schema_context_drives_the_executing_connection() -> IdeResult<()> {
-    const A: &str = "oi_ctx_meta";
-    const B: &str = "oi_ctx_data";
-    let tmp = tempfile::tempdir().unwrap();
-    let Some(db) = manager(&tmp, "").await else { return Ok(()) };
-    let c = CancellationToken::new();
-    for s in [A, B] {
-        for stmt in [
-            format!("DROP DATABASE IF EXISTS `{s}`"),
-            format!("CREATE DATABASE `{s}` CHARACTER SET utf8mb4 COLLATE utf8mb4_bin"),
-            format!("CREATE TABLE `{s}`.`用户` (id INT PRIMARY KEY, name VARCHAR(20))"),
-            format!("INSERT INTO `{s}`.`用户` VALUES (1, '{s}')"),
-        ] {
-            db.execute("m", &stmt, 10, &c).await.unwrap();
-        }
-    }
-
-    // The source connects with no default database; the console's pick decides.
-    let r = db.execute_from("m", "SELECT DATABASE()", 0, 1, &c, Some(A)).await?;
-    assert_eq!(r.rows, vec![vec![Some(A.into())]]);
-    // Both schemas hold `用户`; the context resolves the unqualified name in its own,
-    // on every pooled connection the autocommit statements may land on.
-    for _ in 0..6 {
-        for (schema, name) in [(A, A), (B, B)] {
-            let r = db.execute_from("m", "SELECT name FROM 用户", 0, 1, &c, Some(schema)).await?;
-            assert_eq!(r.rows, vec![vec![Some(name.into())]], "of {schema}");
-            let r = db.execute_from("m", "SELECT DATABASE()", 0, 1, &c, Some("")).await?;
-            assert_eq!(r.rows, vec![vec![None]]);
-            assert_eq!(db.completion("m").await?.default_schema, "");
-        }
-    }
-    // A statement without a selection returns to the source's absent default.
-    let r = db.execute_from("m", "SELECT DATABASE()", 0, 1, &c, None).await?;
-    assert_eq!(r.rows, vec![vec![None]]);
-
-    // A manual-commit console switches schemas on its session connection.
-    db.set_manual_commit("m", true).await?;
-    // Starting a no-database manual session must keep its transaction open.
-    db.execute("m", &format!("INSERT INTO `{A}`.`用户` VALUES (2, 'rollback')"), 1, &c).await?;
-    db.finish_transaction("m", false).await?;
-    assert!(db.execute("m", &format!("SELECT name FROM `{A}`.`用户` WHERE id = 2"), 1, &c).await?.rows.is_empty());
-    let r = db.execute_from("m", "SELECT name FROM 用户", 0, 1, &c, Some(A)).await?;
-    assert_eq!(r.rows, vec![vec![Some(A.into())]]);
-    let r = db.execute_from("m", "SELECT DATABASE()", 0, 1, &c, Some(B)).await?;
-    assert_eq!(r.rows, vec![vec![Some(B.into())]]);
-    assert!(db.execute("m", "SELECT DATABASE()", 1, &c).await.is_err());
-    // The rejected clear keeps the transaction and selection intact.
-    assert_eq!(db.execute_from("m", "SELECT DATABASE()", 0, 1, &c, Some(B)).await?.rows, vec![vec![Some(B.into())]]);
-    db.finish_transaction("m", true).await?;
-    for commit in [false, true] {
-        db.execute_from("m", "SELECT 1", 0, 1, &c, Some(A)).await?;
-        db.finish_transaction("m", commit).await?;
-        let r = db.execute("m", "SELECT DATABASE()", 1, &c).await?;
-        assert_eq!(r.rows, vec![vec![None]]);
-    }
-    db.execute_from("m", "SELECT 1", 0, 1, &c, Some(A)).await?;
-    db.set_manual_commit("m", false).await?;
-    db.execute("m", &format!("USE `{B}`"), 1, &c).await?;
-    let r = db.execute("m", "SELECT DATABASE()", 1, &c).await?;
-    assert_eq!(r.rows, vec![vec![None]]);
-
-    // An unknown schema fails the statement instead of running it somewhere else.
-    let error = db.execute_from("m", "SELECT 1", 0, 1, &c, Some("oi_missing")).await.unwrap_err();
-    assert!(error.message.contains("oi_missing"), "{}", error.message);
-    Ok(())
-}
-
-#[tokio::test]
-async fn a_reused_physical_connection_restores_the_configured_database() -> IdeResult<()> {
-    use ide_db::{Held, Pool};
-    let Some((host, port, user, password)) = server() else { return Ok(()) };
-    let source = DataSource {
-        driver: DbDriver::Mysql,
-        host,
-        port: Some(port),
-        user,
-        database: "mysql".into(),
-        ..Default::default()
-    };
-    let pool = Pool::connect(&source, Some(&password), None).await?;
-    let c = CancellationToken::new();
-    let _other = [Held::acquire(&pool).await?, Held::acquire(&pool).await?, Held::acquire(&pool).await?];
-    let mut conn = Held::acquire(&pool).await?;
-    let backend = conn.execute(&pool, "SELECT CONNECTION_ID()", 1, &c).await?.rows;
-    for schema in ["information_schema", "mysql", "information_schema"] {
-        conn.apply_context(Some(schema)).await?;
-        assert_eq!(conn.execute(&pool, "SELECT DATABASE()", 1, &c).await?.rows, vec![vec![Some(schema.into())]]);
-    }
-    drop(conn);
-    assert_eq!(pool.rows("SELECT DATABASE()", 1).await?, vec![vec![Some("mysql".into())]]);
-    assert_eq!(pool.execute("SELECT CONNECTION_ID()", 1, &c).await?.rows, backend);
-    Ok(())
-}
@@ -1,135 +0,0 @@
-//! The active schema context against a real PostgreSQL server, skipped unless
-//! `OPENIDEA_TEST_POSTGRES=host:port:user:password` names a throwaway server.
-
-use ide_core::{CancellationToken, IdeResult};
-use ide_db::{DataSource, DbDriver, DbManager};
-
-fn server() -> Option<(String, u16, String, String)> {
-    let v = std::env::var("OPENIDEA_TEST_POSTGRES").ok()?;
-    let mut it = v.splitn(4, ':');
-    Some((it.next()?.into(), it.next()?.parse().ok()?, it.next()?.into(), it.next().unwrap_or("").into()))
-}
-
-async fn manager(tmp: &tempfile::TempDir) -> Option<DbManager> {
-    let (host, port, user, password) = server()?;
-    let root = tmp.path().to_path_buf();
-    let ssh = std::sync::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);
-    db.save_sources(vec![DataSource {
-        id: "p".into(),
-        name: "postgres".into(),
-        driver: DbDriver::Postgres,
-        host,
-        port: Some(port),
-        user,
-        ..Default::default()
-    }])
-    .await
-    .unwrap();
-    db.set_password("p", Some(password), false).await.unwrap();
-    Some(db)
-}
-
-async fn create_schemas(db: &DbManager) {
-    let c = CancellationToken::new();
-    for (schema, tag) in [("oi_a", "from a"), ("oi_b", "from b")] {
-        for stmt in [
-            format!("DROP SCHEMA IF EXISTS \"{schema}\" CASCADE"),
-            format!("CREATE SCHEMA \"{schema}\""),
-            format!("CREATE TABLE \"{schema}\".items (id INT PRIMARY KEY, tag TEXT)"),
-            format!("INSERT INTO \"{schema}\".items VALUES (1, '{tag}')"),
-        ] {
-            db.execute("p", &stmt, 10, &c).await.unwrap();
-        }
-    }
-}
-
-#[tokio::test]
-async fn active_schema_context_drives_the_executing_connection() -> IdeResult<()> {
-    let tmp = tempfile::tempdir().unwrap();
-    let Some(db) = manager(&tmp).await else { return Ok(()) };
-    create_schemas(&db).await;
-    let c = CancellationToken::new();
-
-    // The connection default stays untouched before any console picks a schema.
-    let r = db.execute("p", "SHOW search_path", 1, &c).await?;
-    assert!(r.rows[0][0].as_deref().unwrap_or("").contains("public"), "{:?}", r.rows);
-
-    // Both schemas hold `items`; the context resolves the unqualified name in its own,
-    // on every pooled connection the autocommit statements may land on.
-    for _ in 0..6 {
-        for (schema, tag) in [("oi_a", "from a"), ("oi_b", "from b")] {
-            let r = db.execute_from("p", "SELECT tag FROM items", 0, 1, &c, Some(schema)).await?;
-            assert_eq!(r.rows, vec![vec![Some(tag.into())]], "of {schema}");
-            let r = db.execute_from("p", "SHOW search_path", 0, 1, &c, Some("")).await?;
-            assert_eq!(r.rows, vec![vec![Some("\"$user\", public".into())]]);
-            assert_eq!(db.completion("p").await?.default_schema, "public");
-        }
-    }
-
-    // A manual-commit console switches schemas on its session connection.
-    db.set_manual_commit("p", true).await?;
-    let r = db.execute_from("p", "SELECT tag FROM items", 0, 1, &c, Some("oi_a")).await?;
-    assert_eq!(r.rows, vec![vec![Some("from a".into())]]);
-    let r = db.execute_from("p", "SELECT tag FROM items", 0, 1, &c, Some("oi_b")).await?;
-    assert_eq!(r.rows, vec![vec![Some("from b".into())]]);
-    db.finish_transaction("p", true).await?;
-    for commit in [false, true] {
-        db.execute_from("p", "SELECT 1", 0, 1, &c, Some("oi_a")).await?;
-        db.finish_transaction("p", commit).await?;
-        let r = db.execute("p", "SHOW search_path", 1, &c).await?;
-        assert_eq!(r.rows, vec![vec![Some("\"$user\", public".into())]]);
-    }
-    db.set_manual_commit("p", false).await?;
-    db.execute("p", "SET search_path TO oi_b", 1, &c).await?;
-    let r = db.execute("p", "SHOW search_path", 1, &c).await?;
-    assert_eq!(r.rows, vec![vec![Some("\"$user\", public".into())]]);
-
-    // An unknown schema never resolves the statement's tables (`SET search_path`
-    // itself does not validate names; resolution against it does).
-    let error = db.execute_from("p", "SELECT tag FROM items", 0, 1, &c, Some("oi_missing")).await.unwrap_err();
-    assert!(error.message.to_lowercase().contains("does not exist"), "{}", error.message);
-    Ok(())
-}
-
-#[tokio::test]
-async fn a_reused_physical_connection_restores_the_full_default_path() -> IdeResult<()> {
-    use ide_db::{DbOptions, Held, Pool};
-    let Some((host, port, user, password)) = server() else { return Ok(()) };
-    let source = DataSource {
-        driver: DbDriver::Postgres,
-        host,
-        port: Some(port),
-        user,
-        options: DbOptions { default_schema: "public, pg_catalog".into(), ..Default::default() },
-        ..Default::default()
-    };
-    let pool = Pool::connect(&source, Some(&password), None).await?;
-    let c = CancellationToken::new();
-    // Occupy the other three slots: every operation below must reuse the fourth.
-    let _other = [Held::acquire(&pool).await?, Held::acquire(&pool).await?, Held::acquire(&pool).await?];
-    let mut conn = Held::acquire(&pool).await?;
-    let backend = conn.execute(&pool, "SELECT pg_backend_pid()", 1, &c).await?.rows;
-    for schema in ["pg_catalog", "public", "pg_catalog"] {
-        conn.apply_context(Some(schema)).await?;
-        let r = conn.execute(&pool, "SELECT current_schema()", 1, &c).await?;
-        assert_eq!(r.rows, vec![vec![Some(schema.into())]]);
-    }
-    conn.apply_context(Some("public")).await?;
-    conn.execute(&pool, "SELECT set_config('search_path', 'pg_catalog', false)", 1, &c).await?;
-    conn.apply_context(Some("public")).await?;
-    assert_eq!(conn.execute(&pool, "SELECT current_schema()", 1, &c).await?.rows, vec![vec![Some("public".into())]]);
-    drop(conn);
-    assert_eq!(pool.rows("SHOW search_path", 1).await?, vec![vec![Some("public, pg_catalog".into())]]);
-    assert_eq!(pool.execute("SELECT pg_backend_pid()", 1, &c).await?.rows, backend);
-    let mut conn = Held::acquire(&pool).await?;
-    conn.command("BEGIN").await?;
-    conn.apply_context(Some("pg_catalog")).await?;
-    conn.command("ROLLBACK").await?;
-    conn.restore_default().await?;
-    assert_eq!(
-        conn.execute(&pool, "SHOW search_path", 1, &c).await?.rows,
-        vec![vec![Some("public, pg_catalog".into())]]
-    );
-    Ok(())
-}
@@ -1,9 +1,7 @@
 //! Introspection, queries and table edits against a real SQLite file.

 use ide_core::{CancellationToken, IdeResult};
-use ide_db::{
-    CellValue, DataSource, DbDriver, DbManager, DbOptions, DbProperty, DbRowEdit, DbTableKind, QueryResult, SortKey,
-};
+use ide_db::{CellValue, DataSource, DbDriver, DbManager, DbOptions, DbProperty, DbRowEdit, DbTableKind, SortKey};

 async fn setup() -> (tempfile::TempDir, DbManager) {
    let tmp = tempfile::tempdir().unwrap();
@@ -125,28 +123,6 @@ async fn queries_with_limits_nulls_and_blobs() -> IdeResult<()> {
    Ok(())
 }

-#[tokio::test]
-async fn a_later_page_returns_only_its_rows() -> IdeResult<()> {
-    let (_tmp, db) = setup().await;
-    let c = CancellationToken::new();
-    let sql = "SELECT id FROM users ORDER BY id";
-    let ids = |r: &QueryResult| r.rows.iter().map(|row| row[0].clone().unwrap()).collect::<Vec<_>>();
-
-    let second = db.execute_from("s1", sql, 1, 1, &c, None).await?;
-    assert_eq!(ids(&second), vec!["2"]);
-    assert!(second.has_more);
-    assert_eq!(second.columns.len(), 1);
-
-    let last = db.execute_from("s1", sql, 2, 5, &c, None).await?;
-    assert_eq!(ids(&last), vec!["3"]);
-    assert!(!last.has_more);
-
-    let past = db.execute_from("s1", sql, 9, 5, &c, None).await?;
-    assert!(past.rows.is_empty() && !past.has_more);
-    assert_eq!(past.columns.len(), 1, "columns of a page past the end come from the prepared statement");
-    Ok(())
-}
-
 #[tokio::test]
 async fn pages_sorts_filters_and_edits_in_a_transaction() -> IdeResult<()> {
    let (_tmp, db) = setup().await;
@@ -221,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.unwrap();
+    db.set_manual_commit("s1", true).await;
    db.execute("s1", "INSERT INTO users (name) VALUES ('dee')", 1, &c).await?;
    // The session sees its own change.
    assert_eq!(count(&db).await, "4");
@@ -232,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.unwrap();
+    db.set_manual_commit("s1", false).await;
    assert_eq!(count(&db).await, "4");
    // Disconnecting with an open transaction does not hang.
-    db.set_manual_commit("s1", true).await.unwrap();
+    db.set_manual_commit("s1", true).await;
    db.execute("s1", "DELETE FROM users", 1, &c).await?;
    db.disconnect("s1").await;
    assert_eq!(count(&db).await, "4");
@@ -276,11 +252,11 @@ async fn ddl_of_tables_and_views() -> IdeResult<()> {
 async fn explains_queries_without_running_them() -> IdeResult<()> {
    let (_tmp, db) = setup().await;
    let c = CancellationToken::new();
-    let plan = db.explain("s1", "SELECT * FROM users WHERE id > 1 ORDER BY note;", &c, None).await?;
+    let plan = db.explain("s1", "SELECT * FROM users WHERE id > 1 ORDER BY note;", &c).await?;
    let ops: Vec<_> = plan.iter().map(|n| n.operation.as_str()).collect();
    assert_eq!(ops, vec!["Index Scan", "Order By"]);
    assert!(plan[0].params.starts_with("table: users;"), "{}", plan[0].params);
-    db.explain("s1", "DELETE FROM users", &c, None).await?;
+    db.explain("s1", "DELETE FROM users", &c).await?;
    assert_eq!(count(&db).await, "3");
    Ok(())
 }
@@ -440,131 +440,3 @@ pub fn compose_op(
    });
    run_streaming(ep, None, &args, cancel, on_output)
 }
-
-/// Whether `ep` is a daemon on this machine, where a bind mount of the project
-/// is this machine's folder. The CLI's default daemon and a context are looked
-/// up (`DOCKER_CONTEXT`, then `DOCKER_HOST`, else the current context).
-pub fn endpoint_is_local(ep: &DockerEndpoint) -> IdeResult<bool> {
-    let url = match ep {
-        DockerEndpoint::Socket { path } => path.trim().to_owned(),
-        DockerEndpoint::Tcp { host, .. } => {
-            let host = host.trim();
-            if host.contains("://") { host.to_owned() } else { format!("tcp://{host}") }
-        }
-        DockerEndpoint::Default => default_daemon_url(
-            ide_core::process::host_var_os("DOCKER_CONTEXT").as_deref().and_then(|v| v.to_str()),
-            ide_core::process::host_var_os("DOCKER_HOST").as_deref().and_then(|v| v.to_str()),
-            |name| context_host(&DockerEndpoint::Default, name),
-        )?,
-        DockerEndpoint::Context { name } => context_host(&DockerEndpoint::Default, Some(name.trim()))?,
-    };
-    Ok(daemon_url_is_local(&url))
-}
-
-fn default_daemon_url(
-    context: Option<&str>,
-    host: Option<&str>,
-    lookup: impl FnOnce(Option<&str>) -> IdeResult<String>,
-) -> IdeResult<String> {
-    let context = context.filter(|v| !v.is_empty());
-    if context.is_some() {
-        return lookup(context);
-    }
-    match host.filter(|v| !v.is_empty()) {
-        Some(host) => Ok(host.to_owned()),
-        None => lookup(None),
-    }
-}
-
-/// The daemon URL of context `name` (the current one with `None`).
-fn context_host(ep: &DockerEndpoint, name: Option<&str>) -> IdeResult<String> {
-    let mut args = vec!["context", "inspect", "--format", "{{.Endpoints.docker.Host}}"];
-    args.extend(name);
-    Ok(run(ep, &args, QUICK)?.trim().to_owned())
-}
-
-/// `unix://`, `npipe://`, a bare socket path and TCP on the loopback address are
-/// this machine; `ssh://` and other hosts are not.
-pub fn daemon_url_is_local(url: &str) -> bool {
-    let url = url.trim();
-    let Some((scheme, rest)) = url.split_once("://") else { return true };
-    match scheme {
-        "unix" | "npipe" => true,
-        "tcp" | "http" | "https" => {
-            let host = rest.split('/').next().unwrap_or_default();
-            let host = match host.strip_prefix('[') {
-                Some(v6) => v6.split(']').next().unwrap_or_default(),
-                None => host.rsplit_once(':').map_or(host, |(h, _)| h),
-            };
-            matches!(host, "localhost" | "127.0.0.1" | "::1")
-        }
-        _ => false,
-    }
-}
-
-/// `docker compose config --format json` of the project at `dir` (`files`
-/// relative to it; none = the project's default file).
-pub fn compose_config(ep: &DockerEndpoint, dir: &Path, files: &[String]) -> IdeResult<String> {
-    let mut args: Vec<&str> = vec!["compose"];
-    for f in files.iter().map(|f| f.trim()).filter(|f| !f.is_empty()) {
-        args.extend(["--file", f]);
-    }
-    args.extend(["config", "--format", "json"]);
-    let mut cmd = command(ep, &args)?;
-    cmd.current_dir(dir);
-    let out = process::run(cmd, QUICK, None)?;
-    if out.success { Ok(out.stdout) } else { Err(failure(&args, &out.stderr, &out.stdout)) }
-}
-
-#[cfg(test)]
-mod local_tests {
-    use super::*;
-
-    #[test]
-    fn the_selected_context_overrides_docker_host() {
-        let local = "unix:///var/run/docker.sock";
-        let remote = "ssh://me@build";
-        for host in [None, Some(""), Some(local)] {
-            let url = default_daemon_url(Some("build"), host, |name| {
-                assert_eq!(name, Some("build"));
-                Ok(remote.into())
-            })
-            .unwrap();
-            assert!(!daemon_url_is_local(&url));
-        }
-        for context in [None, Some("")] {
-            assert_eq!(
-                default_daemon_url(context, Some(local), |_| panic!("host overrides current context")).unwrap(),
-                local
-            );
-            assert_eq!(
-                default_daemon_url(context, None, |name| {
-                    assert_eq!(name, None);
-                    Ok(remote.into())
-                })
-                .unwrap(),
-                remote
-            );
-        }
-    }
-
-    #[test]
-    fn local_daemon_urls() {
-        for url in [
-            "unix:///var/run/docker.sock",
-            "/var/run/docker.sock",
-            "npipe:////./pipe/docker_engine",
-            "tcp://localhost:2375",
-            "tcp://127.0.0.1:2376",
-            "tcp://[::1]:2375",
-            "",
-        ] {
-            assert!(daemon_url_is_local(url), "{url}");
-        }
-        for url in ["ssh://me@build", "tcp://build:2376", "tcp://10.0.0.5:2375", "https://docker.example.com"] {
-            assert!(!daemon_url_is_local(url), "{url}");
-        }
-        assert!(endpoint_is_local(&DockerEndpoint::Socket { path: "/run/user/1000/docker.sock".into() }).unwrap());
-        assert!(!endpoint_is_local(&DockerEndpoint::Tcp { host: "build:2376".into(), tls_cert_dir: None }).unwrap());
-    }
-}
@@ -18,15 +18,13 @@ pub enum Capability {
    EditorRead,
    /// Edit the focused editor (versioned edits).
    EditorWrite,
-    /// Create and replace files inside the project root.
-    ProjectWrite,
    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 (files, focus, VCS), not keystrokes.
+    /// Workbench events (file opened, saved, focus…), not keystrokes.
    Events,
    /// Keystrokes and editor input events.
    InputEvents,
@@ -38,8 +36,6 @@ pub enum Capability {
    Process(String),
    /// Read files outside the project under one path.
    FsRead(String),
-    /// Write files outside the project under one path.
-    FsWrite(String),
 }

 /// How a grant is presented (plan 4.2).
@@ -58,14 +54,10 @@ impl Capability {
    pub fn risk(&self) -> Risk {
        match self {
            Self::ProjectRead | Self::EditorRead | Self::Storage | Self::Events | Self::VcsRead => Risk::Low,
-            Self::EditorWrite
-            | Self::ProjectWrite
-            | Self::VcsWrite
-            | Self::Net(_)
-            | Self::Secrets
-            | Self::InputEvents
-            | Self::Clipboard => Risk::Medium,
-            Self::Process(_) | Self::FsRead(_) | Self::FsWrite(_) => Risk::High,
+            Self::EditorWrite | Self::VcsWrite | Self::Net(_) | Self::Secrets | Self::InputEvents | Self::Clipboard => {
+                Risk::Medium
+            }
+            Self::Process(_) | Self::FsRead(_) => Risk::High,
        }
    }

@@ -81,20 +73,16 @@ impl Capability {
            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::ProjectWrite => "Create and change files in the open project".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 editor, filesystem and version control events".into(),
+            Self::Events => "Observe workbench events (files opened, saved, focus)".into(),
            Self::InputEvents => "Observe keystrokes and editor input".into(),
-            Self::Clipboard => {
-                "Copy to the clipboard from its commands, and read and write it from its web views".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"),
-            Self::FsWrite(path) => format!("Change files under {path}, outside the project"),
        }
    }

@@ -102,7 +90,7 @@ impl Capability {
    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)) | (Self::FsWrite(base), Self::FsWrite(path)) => {
+            (Self::FsRead(base), Self::FsRead(path)) => {
                std::path::Path::new(path).starts_with(std::path::Path::new(base))
            }
            _ => self == wanted,
@@ -126,7 +114,6 @@ impl fmt::Display for Capability {
            Self::ProjectRead => f.write_str("project.read"),
            Self::EditorRead => f.write_str("editor.read"),
            Self::EditorWrite => f.write_str("editor.write"),
-            Self::ProjectWrite => f.write_str("project.write"),
            Self::VcsRead => f.write_str("vcs.read"),
            Self::VcsWrite => f.write_str("vcs.write"),
            Self::Storage => f.write_str("storage"),
@@ -137,7 +124,6 @@ impl fmt::Display for Capability {
            Self::Net(h) => write!(f, "net:{h}"),
            Self::Process(b) => write!(f, "process:{b}"),
            Self::FsRead(p) => write!(f, "fs.read:{p}"),
-            Self::FsWrite(p) => write!(f, "fs.write:{p}"),
        }
    }
 }
@@ -170,11 +156,11 @@ impl FromStr for Capability {
                    }
                    Ok(Self::Process(arg.to_owned()))
                }
-                "fs.read" | "fs.write" => {
+                "fs.read" => {
                    if !std::path::Path::new(arg).is_absolute() && !arg.starts_with('~') {
                        return Err(format!("{s:?}: use an absolute path (or ~/…)"));
                    }
-                    Ok(if kind == "fs.read" { Self::FsRead(arg.to_owned()) } else { Self::FsWrite(arg.to_owned()) })
+                    Ok(Self::FsRead(arg.to_owned()))
                }
                _ => Err(format!("unknown capability {s:?}")),
            };
@@ -183,7 +169,6 @@ impl FromStr for Capability {
            "project.read" | "project-read" => Self::ProjectRead,
            "editor.read" | "editor-read" => Self::EditorRead,
            "editor.write" | "editor-write" => Self::EditorWrite,
-            "project.write" => Self::ProjectWrite,
            "vcs.read" => Self::VcsRead,
            "vcs.write" => Self::VcsWrite,
            "storage" => Self::Storage,
@@ -237,7 +222,6 @@ mod tests {
        for s in [
            "project.read",
            "editor.write",
-            "project.write",
            "vcs.write",
            "storage",
            "secrets",
@@ -250,12 +234,12 @@ mod tests {
            assert_eq!(s.parse::<Capability>().unwrap().to_string(), s);
        }
        // Absolute paths are the platform's.
-        let (git, etc, out) = if cfg!(windows) {
-            (r"process:C:\Program Files\Git\bin\git.exe", r"fs.read:C:\Windows", r"fs.write:C:\out")
+        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", "fs.write:/out")
+            ("process:/usr/bin/git", "fs.read:/etc")
        };
-        for s in [git, etc, out] {
+        for s in [git, etc] {
            assert_eq!(s.parse::<Capability>().unwrap().to_string(), s);
        }
        assert_eq!("project-read".parse::<Capability>().unwrap(), Capability::ProjectRead);
@@ -263,7 +247,6 @@ mod tests {
        assert!("net:a b".parse::<Capability>().is_err());
        assert!("process:./evil".parse::<Capability>().is_err());
        assert!("fs.read:rel".parse::<Capability>().is_err());
-        assert!("fs.write:rel".parse::<Capability>().is_err());
        assert!("network".parse::<Capability>().is_err());
    }

@@ -308,13 +308,6 @@ pub fn by_risk(caps: &[Capability]) -> Vec<(Risk, Vec<Capability>)> {

 /// 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`.
-/// The directory is canonicalized but the file name kept as found: `cargo`,
-/// `rustc` and friends are often links to a multicall shim (rustup, asdf,
-/// mise) that picks the tool by the name it was invoked under — resolving the
-/// link itself would start the shim with the tool's arguments. The grant
-/// still pins the target's content: a hash read through a link reads the file
-/// it points to, so relinking or replacing either still fails the
-/// approved-file check.
 pub fn resolve_program(name: &str, path_var: Option<&OsStr>) -> Result<PathBuf, String> {
    let candidate = Path::new(name);
    if candidate.is_absolute() {
@@ -332,21 +325,15 @@ pub fn resolve_program(name: &str, path_var: Option<&OsStr>) -> Result<PathBuf,
        for ext in &exts {
            let p = dir.join(format!("{name}{ext}"));
            if is_executable(&p) {
-                return Ok(canonical_dir(&p));
+                return Ok(dunce_canonical(&p));
            }
        }
    }
    Err(format!("{name} was not found on PATH"))
 }

-/// `p` with its parent canonicalized but the file name as found: PATH
-/// entries like `/var` → `/private/var` (macOS) or `~` links collapse to
-/// their real directory, while a linked program (`cargo` → rustup) keeps
-/// its link name so the shim still dispatches on argv[0].
-fn canonical_dir(p: &Path) -> PathBuf {
-    let Some(dir) = p.parent() else { return p.to_path_buf() };
-    let Some(name) = p.file_name() else { return p.to_path_buf() };
-    std::fs::canonicalize(dir).map(|d| d.join(name)).unwrap_or_else(|_| p.to_path_buf())
+fn dunce_canonical(p: &Path) -> PathBuf {
+    std::fs::canonicalize(p).unwrap_or_else(|_| p.to_path_buf())
 }

 fn is_executable(p: &Path) -> bool {
@@ -377,7 +364,7 @@ pub fn package_hash(dir: &Path, files: &[PathBuf]) -> std::io::Result<String> {
    sorted.dedup();
    let mut hasher = blake3::Hasher::new();
    for rel in sorted {
-        hasher.update(hashed_path(rel).as_bytes());
+        hasher.update(rel.to_string_lossy().as_bytes());
        hasher.update(&[0]);
        hasher.update_reader(std::fs::File::open(dir.join(rel))?)?;
        hasher.update(&[0]);
@@ -385,12 +372,6 @@ pub fn package_hash(dir: &Path, files: &[PathBuf]) -> std::io::Result<String> {
    Ok(hasher.finalize().to_hex().to_string())
 }

-/// A package-relative path as hashed: `/`-separated on every OS, so a package has one digest
-/// (a walked `web\index.html` on Windows is `web/index.html` everywhere else).
-fn hashed_path(rel: &Path) -> String {
-    rel.components().map(|c| c.as_os_str().to_string_lossy()).collect::<Vec<_>>().join("/")
-}
-
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -487,42 +468,6 @@ mod tests {
        assert!(l.check_binary(&r.subject, &cap).unwrap_err().contains("changed"));
    }

-    /// A program found as a link stays the link: multicall shims (rustup,
-    /// asdf, mise) pick the tool by the name they were invoked under, so
-    /// `Command::new` must see the link. The hash still covers the target —
-    /// reading through the link reads it — so replacing either still trips
-    /// the approved-file check.
-    #[cfg(unix)]
-    #[test]
-    fn linked_programs_resolve_to_the_link() {
-        use std::os::unix::fs::PermissionsExt;
-        let tmp = tempfile::tempdir().unwrap();
-        let bin_dir = tmp.path().join("bin");
-        let real_dir = tmp.path().join("real");
-        std::fs::create_dir(&bin_dir).unwrap();
-        std::fs::create_dir(&real_dir).unwrap();
-        let target = real_dir.join("shim");
-        std::fs::write(&target, "#!/bin/sh\necho v1\n").unwrap();
-        std::fs::set_permissions(&target, std::fs::Permissions::from_mode(0o755)).unwrap();
-        std::os::unix::fs::symlink(&target, bin_dir.join("cargo")).unwrap();
-
-        let path_var = std::env::join_paths([bin_dir.clone()]).unwrap();
-        let resolved = resolve_program("cargo", Some(&path_var)).unwrap();
-        // Directory canonicalized, file name kept — still the link.
-        let want = std::fs::canonicalize(&bin_dir).unwrap().join("cargo");
-        assert_eq!(resolved, want);
-        assert!(resolved.symlink_metadata().unwrap().file_type().is_symlink());
-
-        let mut l = Ledger::in_memory();
-        let r = req("1.0.0", "h", &["process:cargo"], &[]);
-        let cap: Capability = "process:cargo".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(&target, "#!/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();
@@ -535,20 +480,4 @@ mod tests {
        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]);
    }
-
-    #[test]
-    fn hashes_paths_with_forward_slashes_on_every_os() {
-        assert_eq!(hashed_path(Path::new("web/index.html")), "web/index.html");
-        assert_eq!(hashed_path(Path::new("plugin.wasm")), "plugin.wasm");
-        #[cfg(windows)]
-        assert_eq!(hashed_path(Path::new(r"web\index.html")), "web/index.html");
-        let tmp = tempfile::tempdir().unwrap();
-        std::fs::create_dir(tmp.path().join("web")).unwrap();
-        std::fs::write(tmp.path().join("web").join("index.html"), "<p>").unwrap();
-        // A walked path (native separators) hashes like the manifest's `/` spelling.
-        assert_eq!(
-            package_hash(tmp.path(), &[Path::new("web").join("index.html")]).unwrap(),
-            package_hash(tmp.path(), &["web/index.html".into()]).unwrap()
-        );
-    }
 }
@@ -27,10 +27,10 @@ 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,
+    ActivationEvent, Capabilities, ENGINE_VERSION, EVENT_KINDS, LEGACY_API, MANIFEST_FILE, 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, LOCALES_DIR, LOCALES_POINT, PreparedSet};
+pub use registry::{ContributionInfo, ExtensionRegistry, PreparedSet};
 pub use ui::{UiContribution, UiDecl, UiPoint, UiStore, to_json};
 pub use when::validate_when;
@@ -32,14 +32,9 @@ 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.3.0";
+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 {
@@ -52,12 +47,6 @@ pub struct Manifest {
    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>,
-    /// SVG shown in Settings › Plugins and the marketplace.
-    pub icon: Option<PathBuf>,
-    /// Its variant for dark themes.
-    pub icon_dark: Option<PathBuf>,
    /// `engines.openidea` (a semver requirement), or the legacy `openidea-api`.
    pub engine: String,
    /// Written in the 0.1 format.
@@ -144,8 +133,7 @@ impl ActivationEvent {

 /// 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", "files-changed", "editor-focused", "action-performed", "vcs-changed"];
+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 {
@@ -178,12 +166,6 @@ struct Raw {
    #[serde(default)]
    change_notes: Option<String>,
    #[serde(default)]
-    categories: Vec<String>,
-    #[serde(default)]
-    icon: Option<PathBuf>,
-    #[serde(default)]
-    icon_dark: Option<PathBuf>,
-    #[serde(default)]
    engines: Option<Engines>,
    /// 0.1 format.
    #[serde(default)]
@@ -261,9 +243,6 @@ impl Manifest {
            homepage: raw.homepage,
            license: raw.license,
            change_notes: raw.change_notes,
-            declared_categories: raw.categories,
-            icon: raw.icon,
-            icon_dark: raw.icon_dark,
            engine,
            legacy,
            wasm: raw.wasm,
@@ -281,16 +260,6 @@ impl Manifest {
        Self::parse(&src).map_err(|e| format!("{}: {e}", path.display()))
    }

-    /// Refuses `what`, new in plugin API 1.`minor`, while `engines.openidea`
-    /// still admits an older 1.x: those IDEs reject the manifest at install.
-    pub fn needs_api(&self, what: &str, minor: u64) -> Result<(), String> {
-        let older = |m| engine_compatible_with(&self.engine, &semver::Version::new(1, m, u64::MAX));
-        if self.legacy || (0..minor).any(older) {
-            return Err(format!("{what} is new in plugin API 1.{minor}: set engines.openidea to \"^1.{minor}\""));
-        }
-        Ok(())
-    }
-
    fn validate(&self) -> Result<(), String> {
        validate_plugin_id(&self.id)?;
        if self.name.trim().is_empty() {
@@ -312,36 +281,15 @@ impl Manifest {
        if let Some(wasm) = &self.wasm {
            check_relative(wasm, "wasm")?;
        }
-        if let Some(icon) = &self.icon {
-            self.needs_api("`icon`", 2)?;
-            check_relative(icon, "icon")?;
-        }
-        for cap in self.capabilities.required.iter().chain(&self.capabilities.optional) {
-            if matches!(cap, Capability::ProjectWrite | Capability::FsWrite(_)) {
-                self.needs_api(&format!("capability `{cap}`"), 3)?;
-            }
-        }
-        if let Some(dark) = &self.icon_dark {
-            if self.icon.is_none() {
-                return Err("`icon-dark` needs `icon`".into());
-            }
-            check_relative(dark, "icon-dark")?;
-        }
        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 matches!(event, ActivationEvent::Event(kind) if kind == "files-changed") {
-                self.needs_api("`on-event:files-changed`", 3)?;
-            }
            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(_)) {
@@ -377,49 +325,14 @@ impl Manifest {
    }
 }

-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('.'));
    }
-    engine_compatible_with(engine, &semver::Version::parse(ENGINE_VERSION).expect("valid engine version"))
-}
-
-fn engine_compatible_with(engine: &str, api: &semver::Version) -> bool {
-    semver::VersionReq::parse(engine).is_ok_and(|req| req.matches(api))
+    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
@@ -499,35 +412,11 @@ mod tests {
    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");
-        assert_eq!(
-            ActivationEvent::parse("on-event:files-changed"),
-            Ok(ActivationEvent::Event("files-changed".into()))
-        );
        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();
@@ -594,51 +483,6 @@ mod tests {
        assert!(err("id = \"ok\"\nname = \"N\"\nversion = \"1.0\"\nengines.openidea = \"^1.0\"").contains("version"));
    }

-    const BASE: &str = "id = \"ok\"\nname = \"N\"\nversion = \"1.0.0\"\nengines.openidea = \"^1.2\"\n";
-
-    #[test]
-    fn files_changed_activation_needs_api_1_3() {
-        let activation = "wasm = \"plugin.wasm\"\nactivation = [\"on-event:files-changed\"]\n";
-        for engine in ["^1.0", "^1.2", ">=1.1, <2"] {
-            let base = BASE.replace("^1.2", engine);
-            assert!(err(&format!("{base}{activation}")).contains("new in plugin API 1.3"), "{engine}");
-        }
-        for engine in ["^1.3", ">=1.3, <2"] {
-            Manifest::parse(&format!("{}{activation}", BASE.replace("^1.2", engine))).unwrap();
-        }
-        Manifest::parse(&format!("{BASE}{}", activation.replace("files-changed", "file-saved"))).unwrap();
-    }
-
-    #[test]
-    fn write_capabilities_need_api_1_3() {
-        for cap in ["project.write", "fs.write:~/tool"] {
-            let caps = format!("[capabilities]\noptional = [\"{cap}\"]\n");
-            assert!(err(&format!("{BASE}{caps}")).contains("new in plugin API 1.3"), "{cap}");
-            let m = Manifest::parse(&format!("{}{caps}", BASE.replace("^1.2", "^1.3"))).unwrap();
-            assert_eq!(m.capabilities.optional[0].to_string(), cap);
-        }
-    }
-
-    #[test]
-    fn parses_icons() {
-        let m = Manifest::parse(&format!("{BASE}icon = \"icon.svg\"\nicon-dark = \"icon_dark.svg\"\n")).unwrap();
-        assert_eq!(m.icon.as_deref(), Some(Path::new("icon.svg")));
-        assert_eq!(m.icon_dark.as_deref(), Some(Path::new("icon_dark.svg")));
-        assert_eq!(Manifest::parse(BASE).unwrap().icon, None);
-    }
-
-    #[test]
-    fn rejects_invalid_icons() {
-        assert!(err(&format!("{BASE}icon-dark = \"d.svg\"\n")).contains("`icon-dark` needs `icon`"));
-        assert!(err(&format!("{BASE}icon = \"../x.svg\"\n")).contains("icon"));
-        assert!(err(&format!("{BASE}icon = \"/abs.svg\"\n")).contains("icon"));
-        assert!(err(&format!("{BASE}icon = \"i.svg\"\nicon-dark = \"../d.svg\"\n")).contains("icon-dark"));
-        for engine in ["^1.0", ">=1.1, <2"] {
-            let old = BASE.replace("^1.2", engine);
-            assert!(err(&format!("{old}icon = \"i.svg\"\n")).contains("new in plugin API 1.2"), "{engine}");
-        }
-    }
-
    #[test]
    fn ids() {
        assert!(validate_plugin_id("openidea.material-icons").is_ok());
@@ -9,19 +9,9 @@
 //!   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`]).
+//!   the published plugins, 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.

 use crate::MANIFEST_FILE;
 use base64::Engine as _;
@@ -50,24 +40,6 @@ 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")]
@@ -102,12 +74,6 @@ impl PublisherKey {
        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 {
@@ -122,11 +88,19 @@ 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())
-        }
+        let key: [u8; 32] = B64
+            .decode(&self.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(&self.signature)
+            .ok()
+            .and_then(|b| b.try_into().ok())
+            .ok_or_else(|| "signature: malformed".to_owned())?;
+        key.verify_strict(&signed_message(id, version, digest), &Signature::from_bytes(&sig))
+            .map_err(|_| "the signature does not match the package (it was changed after signing)".to_owned())
    }
 }

@@ -268,10 +242,6 @@ pub struct Index {
    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)]
@@ -283,7 +253,7 @@ pub struct Publisher {
    pub keys: Vec<KeyEntry>,
 }

-#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, specta::Type)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, specta::Type)]
 #[serde(rename_all = "camelCase")]
 pub struct KeyEntry {
    /// Ed25519 public key, base64.
@@ -291,35 +261,6 @@ pub struct KeyEntry {
    /// 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 plugin's own icon (`icon`, `icon-dark` of its manifest): sanitised SVG markup.
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, specta::Type)]
-#[serde(rename_all = "camelCase")]
-pub struct PluginIcon {
-    pub light: String,
-    pub dark: Option<String>,
 }

 /// A published plugin version.
@@ -340,38 +281,6 @@ pub struct IndexEntry {
    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>,
-    /// The manifest's icon, sanitised by whoever wrote the index and again by
-    /// the IDE before showing it.
-    #[serde(default)]
-    pub icon: Option<PluginIcon>,
-}
-
-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.
@@ -385,71 +294,12 @@ pub struct Revocation {
 }

 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}"));
+        let index: Index = serde_json::from_str(text).map_err(|e| format!("index: {e}"))?;
+        if index.format != INDEX_FORMAT {
+            return Err(format!("index format {} is not supported (this IDE reads {INDEX_FORMAT})", index.format));
        }
-        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;
+        Ok(index)
    }

    /// The revocation that applies to `id` at `version`.
@@ -485,127 +335,6 @@ impl Index {
        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)]
@@ -625,7 +354,7 @@ mod tests {
            publishers: vec![Publisher {
                id: "acme".into(),
                name: "ACME".into(),
-                keys: vec![KeyEntry::new(key.public_base64())],
+                keys: vec![KeyEntry { key: key.public_base64(), revoked: false }],
            }],
            plugins: Vec::new(),
            revoked: vec![Revocation {
@@ -633,7 +362,6 @@ mod tests {
                versions: vec!["1.0.0".into()],
                reason: "malware".into(),
            }],
-            moved: None,
        }
    }

@@ -671,139 +399,6 @@ mod tests {
        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(),
-            icon: None,
-        }
-    }
-
-    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();
@@ -818,7 +413,7 @@ mod tests {
        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());
+        assert!(Index::parse(r#"{"format": 2}"#).is_err());
    }

    fn zip_of(path: &Path, entries: &[(&str, &str)]) {
@@ -867,102 +462,4 @@ mod tests {
            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);
-    }
 }
@@ -9,11 +9,6 @@ use std::collections::BTreeMap;
 use std::path::PathBuf;
 use std::sync::Arc;

-/// The point behind a package's `locales/<tag>.json` catalogs: it has no
-/// `[[contributes.locales]]` table, the directory declares it.
-pub const LOCALES_POINT: &str = "locales";
-pub const LOCALES_DIR: &str = "locales";
-
 /// A contribution as the plugin details page lists it.
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
 #[serde(rename_all = "camelCase")]
@@ -132,20 +127,6 @@ impl ExtensionRegistry {
                set.items.push((point.id(), prepared));
            }
        }
-        if let Some(point) = self.point(LOCALES_POINT)
-            && !pkg.manifest.contributes.contains_key(LOCALES_POINT)
-            && pkg.dir.join(LOCALES_DIR).is_dir()
-        {
-            let prepared = point
-                .prepare(pkg, toml::Value::Table(Default::default()))
-                .map_err(|e| format!("{LOCALES_DIR}: {}", strip_prefix(&e, LOCALES_POINT)))?;
-            for f in &prepared.files {
-                if !set.files.contains(f) {
-                    set.files.push(f.clone());
-                }
-            }
-            set.items.push((point.id(), prepared));
-        }
        Ok(set)
    }

@@ -98,15 +98,7 @@ fn parse_unary(t: &[Tok], p: &mut usize, src: &str) -> Result<(), String> {
            *p += 1;
            Ok(())
        }
-        Some(Tok::Id(id)) => {
-            if let Some(path) = id.strip_prefix("workspaceContains:")
-                && (path.is_empty()
-                    || path.starts_with('/')
-                    || path.contains('\\')
-                    || path.split('/').any(|s| s == ".."))
-            {
-                return Err(format!("workspaceContains: needs a relative path inside the project: {src}"));
-            }
+        Some(Tok::Id(_)) => {
            *p += 1;
            if matches!(t.get(*p), Some(Tok::Op("==" | "!="))) {
                *p += 1;
@@ -141,23 +133,4 @@ mod tests {
            assert!(validate_when(bad).is_err(), "{bad}");
        }
    }
-
-    #[test]
-    fn workspace_contains_paths_stay_in_the_project() {
-        for ok in [
-            "workspaceContains:pom.xml",
-            "workspaceContains:.devcontainer/devcontainer.json",
-            "!workspaceContains:a/b && editorFocus",
-        ] {
-            assert!(validate_when(ok).is_ok(), "{ok}");
-        }
-        for bad in [
-            "workspaceContains:",
-            "workspaceContains:/etc/passwd",
-            "workspaceContains:../x",
-            "workspaceContains:a/../../x",
-        ] {
-            assert!(validate_when(bad).unwrap_err().contains("workspaceContains"), "{bad}");
-        }
-    }
 }
@@ -21,18 +21,6 @@ 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
@@ -207,9 +195,7 @@ 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>()
@@ -285,16 +271,14 @@ 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, DWriteCreateFactory, IDWriteFactory, IDWriteFactory3, IDWriteFactory5, IDWriteFont,
-        IDWriteFont1, IDWriteFontCollection, IDWriteFontFamily, IDWriteLocalizedStrings,
+        DWRITE_FACTORY_TYPE_SHARED, DWRITE_FONT_STRETCH_NORMAL, DWRITE_FONT_STYLE_NORMAL, DWRITE_FONT_WEIGHT_NORMAL,
+        DWriteCreateFactory, IDWriteFactory, IDWriteFont1, IDWriteLocalizedStrings,
    };
-    use windows::core::{BOOL, Interface, PCWSTR, w};
+    use windows::core::{BOOL, Interface, w};

-    /// The installed families, named in English when the family has an
-    /// English name (what CSS matches), else its first name.
+    /// The system font collection's 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()
@@ -302,85 +286,11 @@ 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;
-        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();
+        unsafe { factory.GetSystemFontCollection(&mut collection, refresh) }?;
+        let Some(collection) = collection else {
+            return Ok(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 {
@@ -389,120 +299,19 @@ mod imp {
            let Some(name) = unsafe { family.GetFamilyNames() }.ok().and_then(|n| unsafe { english(&n) }) else {
                continue;
            };
-            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");
-                }
+            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));
        }
+        Ok(out)
    }

    unsafe fn english(names: &IDWriteLocalizedStrings) -> Option<String> {
@@ -667,15 +476,6 @@ 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";
@@ -1,145 +0,0 @@
-//! 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());
-    }
-}
@@ -3,11 +3,9 @@
 //!
 //! 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};
@@ -14,10 +14,8 @@ 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
-blake3.workspace = true
 ide-index.workspace = true
 ide-syntax.workspace = true
 ide-search.workspace = true
@@ -46,10 +44,8 @@ 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, features = ["raw_value"] }
+serde_json.workspace = true
 toml.workspace = true
 specta.workspace = true
 specta-typescript.workspace = true
@@ -61,13 +57,12 @@ 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 }
+zip.workspace = true

 [target.'cfg(unix)'.dependencies]
 rustix = { version = "1.1", features = ["fs", "process"] }
@@ -3,15 +3,13 @@
 //! ```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 check [dir]             # 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
+//! openidea-plugin index <dir> --publisher ID --name NAME --key F     # marketplace index.json
 //! ```
 //!
 //! `link` writes `links.json` in the IDE's plugins directory
@@ -22,7 +20,7 @@
 mod templates;

 use ide_extension::{Manifest, validate_plugin_id};
-use ide_host::plugins::{PluginHost, plugin_icon, read_market_url, resolve_market_href};
+use ide_host::plugins::PluginHost;
 use ide_plugin::{Limits, PluginEngine};
 use std::path::{Path, PathBuf};
 use std::process::{Command, ExitCode};
@@ -33,31 +31,17 @@ 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
+        create a plugin; T = command (default), theme, icon-theme, language
  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
+  check [dir]             validate the package 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
+  index <dir> --publisher ID --name NAME --key F [--out FILE]
+                          write the marketplace index.json for the packages in dir

 environment:
  OPENIDEA_PLUGINS_DIR    the IDE's plugins directory (default: the app data directory)";
@@ -67,15 +51,13 @@ fn main() -> ExitCode {
    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("check") => dir_arg(&args[1..]).and_then(|d| check(&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(())
@@ -179,7 +161,7 @@ fn cmd_new(args: &[String]) -> Result<(), String> {
    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)?),
+        templates::Template::Command => Some(sdk_path(a.value("sdk"), &dir)?),
        _ => None,
    };
    let vars = templates::Vars { id: &id, name: &name, sdk: sdk.as_deref() };
@@ -234,16 +216,12 @@ fn title_case(s: &str) -> String {
        .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> {
+/// The SDK dependency path written into a new plugin's Cargo.toml: `--sdk`,
+/// or the SDK of the source tree this tool was built from.
+fn sdk_path(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"))),
-        },
+        None => PathBuf::from(concat!(env!("CARGO_MANIFEST_DIR"), "/../../sdk/rust/openidea-plugin")),
    };
    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())
@@ -252,11 +230,9 @@ fn sdk_dependency(explicit: Option<&str>, plugin_dir: &Path) -> Result<String, S
        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('\\', "/")))
+    Ok(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());
@@ -347,21 +323,10 @@ fn ensure_wasm_target() {

 /// 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 scratch = std::env::temp_dir().join(format!("openidea-plugin-check-{}", std::process::id()));
+    let result = (|| {
        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())?;
@@ -380,17 +345,6 @@ fn check(dir: &Path) -> Result<(), String> {
        } 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(", "));
@@ -407,7 +361,9 @@ fn check(dir: &Path) -> Result<(), String> {
        }
        println!("ok");
        Ok(())
-    })()
+    })();
+    let _ = std::fs::remove_dir_all(&scratch);
+    result
 }

 fn human_size(bytes: u64) -> String {
@@ -523,31 +479,14 @@ fn cmd_keygen(args: &[String]) -> Result<(), String> {
    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())
+    let scratch = std::env::temp_dir().join(format!("openidea-plugin-pack-{}", std::process::id()));
+    let result = PluginHost::new(scratch.clone(), Arc::new(|_: Option<&str>, _| {}), Limits::default())
        .map_err(|e| e.to_string())
-        .and_then(|h| f(&h))
+        .and_then(|h| f(&h));
+    let _ = std::fs::remove_dir_all(&scratch);
+    result
 }

 fn cmd_pack(args: &[String]) -> Result<(), String> {
@@ -583,28 +522,29 @@ fn cmd_pack(args: &[String]) -> Result<(), String> {
 }

 fn cmd_index(args: &[String]) -> Result<(), String> {
-    let a = Args::parse(args, &[], &["publisher", "name", "key", "previous-key", "out", "download-base"])?;
+    let a = Args::parse(args, &[], &["publisher", "name", "key", "out"])?;
    let dir = canonical(&a.dir()?)?;
+    let publisher = a.value("publisher").ok_or("--publisher is required")?;
+    let name = a.value("name").unwrap_or(publisher);
+    let key = read_key(a.value("key").ok_or("--key is required")?)?;
    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())?,
+        Ok(text) => Index::parse(&text)?,
        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()),
-    };
+    // Earlier keys of the publisher stay listed (packages they signed remain valid until revoked).
+    let current = key.public_base64();
+    let earlier: Vec<KeyEntry> = index
+        .publishers
+        .iter()
+        .filter(|p| p.id == publisher)
+        .flat_map(|p| p.keys.iter().filter(|k| k.key != current).cloned())
+        .collect();
+    index.publishers.retain(|p| p.id != publisher);
+    let keys: Vec<KeyEntry> = std::iter::once(KeyEntry { key: current, revoked: false }).chain(earlier).collect();
+    index.publishers.push(package::Publisher { id: publisher.into(), name: name.into(), keys });
+    index.plugins.clear();
    let mut packages: Vec<PathBuf> = std::fs::read_dir(&dir)
        .map_err(|e| e.to_string())?
        .flatten()
@@ -612,145 +552,35 @@ fn cmd_index(args: &[String]) -> Result<(), String> {
        .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 scratch = std::env::temp_dir().join(format!("openidea-plugin-index-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&scratch);
+        let unpacked = package::unpack(&path, &scratch)?;
        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();
+            let sig = unpacked.signature.as_ref().ok_or_else(|| format!("{}: not signed", path.display()))?;
+            sig.check(&m.id, &m.version, &digest).map_err(|e| format!("{}: {e}", path.display()))?;
            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}")),
+                publisher: sig.publisher.clone(),
+                download: path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default(),
                digest,
                capabilities: m.capabilities.all().map(|c| c.to_string()).collect(),
-                engine: package::engine_requirement(&m.engine, built_for.as_ref()),
-                categories: m.categories(),
-                icon: plugin_icon(&ide_extension::Package::new(m.clone(), scratch.clone()))?,
            })
        })();
-        let entry = entry.map_err(|e| format!("{}: {e}", path.display()))?;
-        println!("  {} {} (plugin API {})", entry.id, entry.version, entry.engine);
-        added.push(entry);
+        let _ = std::fs::remove_dir_all(&scratch);
+        let entry = entry?;
+        println!("  {} {}", entry.id, entry.version);
+        index.plugins.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()))?;
+    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(())
 }
@@ -759,25 +589,6 @@ fn write_index(index: &Index, out: &Path) -> Result<(), String> {
 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");
@@ -790,226 +601,13 @@ mod tests {
        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.2", 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 };
-        // A manifest icon needs API 1.2.
-        let icon = if engine == "^1.2" { "\nicon = \"icon.svg\"" } else { "" };
-        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}\"{icon}"));
-            std::fs::write(path, content).unwrap();
-        }
-        std::fs::write(src.join("icon.svg"), r#"<svg viewBox="0 0 16 16"><rect width="16" height="16"/></svg>"#)
-            .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!(
-            index.plugins[1].icon.as_ref().is_some_and(|i| i.light.contains("<rect")),
-            "{:?}",
-            index.plugins[1].icon
-        );
-        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}");
-    }
-
-    #[test]
-    fn the_index_carries_plugin_icons() {
-        let tmp = tempfile::tempdir().unwrap();
-        let t = tmp.path();
-        let key = t.join("acme.key");
-        std::fs::write(&key, PublisherKey::from_seed([6; 32]).seed_base64()).unwrap();
-        let src = t.join("src");
-        let vars = templates::Vars { id: "acme.iconic", name: "Iconic", 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();
-            std::fs::write(path, content).unwrap();
-        }
-        let manifest = std::fs::read_to_string(src.join("plugin.toml")).unwrap();
-        let manifest = manifest.replace("engines.openidea = \"^1.0\"", "engines.openidea = \"^1.2\"");
-        std::fs::write(src.join("plugin.toml"), format!("icon = \"icon.svg\"\n{manifest}")).unwrap();
-        std::fs::write(src.join("icon.svg"), r#"<svg viewBox="0 0 16 16"><rect width="16" height="16"/></svg>"#)
-            .unwrap();
-        let out = t.join("out");
-        std::fs::create_dir_all(&out).unwrap();
-        let (src, key) = (src.to_string_lossy().into_owned(), key.to_string_lossy().into_owned());
-        let package = out.join("acme.iconic-0.1.0.oiplugin").to_string_lossy().into_owned();
-        cmd_pack(&strings(&[&src, "--key", &key, "--publisher", "acme", "--out", &package])).unwrap();
-        cmd_index(&strings(&[out.to_str().unwrap(), "--publisher", "acme", "--key", &key])).unwrap();
-        let index = Index::parse(&std::fs::read_to_string(out.join("index.json")).unwrap()).unwrap();
-        assert!(index.plugins[0].icon.as_ref().expect("icon").light.contains("<rect"));
-    }
-
-    /// `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\" }") };
+            let vars = templates::Vars { id: "acme.sample", name: "Sample", sdk: Some("../sdk") };
            for (rel, content) in templates::render(t, &vars) {
                let path = dir.join(rel);
                std::fs::create_dir_all(path.parent().unwrap()).unwrap();
@@ -32,7 +32,6 @@ impl Template {
 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>,
 }

@@ -83,9 +82,6 @@ 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.
@@ -119,7 +115,7 @@ publish = false
 crate-type = ["cdylib", "rlib"]

 [dependencies]
-openidea-plugin = __SDK__
+openidea-plugin = { path = "__SDK__" }

 [profile.release]
 opt-level = "s"
@@ -131,7 +127,7 @@ panic = "abort"

 const COMMAND_LIB: &str = r#"//! __NAME__: an OpenIDEA plugin.

-use openidea_plugin::{Error, Invocation, NotificationLevel, Plugin, host, register_plugin};
+use openidea_plugin::{Invocation, NotificationLevel, Plugin, host, register_plugin};

 #[derive(Default)]
 pub struct Main {
@@ -139,7 +135,7 @@ pub struct Main {
 }

 impl Plugin for Main {
-    fn run_command(&mut self, id: &str, ctx: &Invocation, _arg: Option<&str>) -> Result<Option<String>, Error> {
+    fn run_command(&mut self, id: &str, ctx: &Invocation, _arg: Option<&str>) -> Result<Option<String>, String> {
        match id {
            "say-hello" => {
                // Instance state lasts until the plugin is idle for a while;
@@ -154,7 +150,7 @@ impl Plugin for Main {
                let text = editor.document()?.text;
                Ok(Some(format!("{} lines in {}", text.lines().count(), editor.path())))
            }
-            _ => Err(format!("unknown command {id}").into()),
+            _ => Err(format!("unknown command {id}")),
        }
    }
 }
@@ -15,22 +15,8 @@ fn main() {
        println!("openidea-server {} (protocol {})", env!("CARGO_PKG_VERSION"), rpc::PROTOCOL_VERSION);
        return;
    }
-    if args.first().is_some_and(|a| a == "--connect") {
-        // One forwarded connection (see `ide_host::relay`): stdout carries its bytes.
-        let code = match ide_host::relay::parse_args(&args[1..]).and_then(|(host, port)| {
-            ide_host::relay::relay(&host, port, std::io::stdin(), std::io::stdout().lock())
-                .map_err(|e| format!("cannot connect to {host}:{port}: {e}"))
-        }) {
-            Ok(()) => 0,
-            Err(e) => {
-                eprintln!("{e}");
-                1
-            }
-        };
-        std::process::exit(code);
-    }
    if !args.iter().any(|a| a == "--stdio") {
-        eprintln!("usage: openidea-server --stdio | --connect <host> <port> | --version");
+        eprintln!("usage: openidea-server --stdio | --version");
        std::process::exit(2);
    }
    // stdout carries the protocol: logs go to stderr.
@@ -92,11 +78,6 @@ async fn run(base: PathBuf) -> i32 {
            None
        }
    };
-    if let Some(root) = std::env::var_os(ide_host::trust::TRUSTED_ROOT_ENV)
-        && let Err(e) = host.trust.inherit(std::path::Path::new(&root))
-    {
-        tracing::warn!("cannot trust {}: {e}", root.to_string_lossy());
-    }
    tracing::info!("openidea-server {} ready", env!("CARGO_PKG_VERSION"));
    let mut dispatcher = Dispatcher::standard();
    if let Some(plugins) = &plugins {
@@ -22,10 +22,6 @@ use std::time::Duration;

 type Changes = Vec<(OsString, Option<OsString>)>;

-/// Set by the desktop when the Dev Containers CLI already ran the lifecycle commands
-/// (`devcontainer up`): the server then doesn't run `postStartCommand` again.
-pub const LIFECYCLE_DONE_ENV: &str = "OPENIDEA_LIFECYCLE_DONE";
-
 /// What Reload Environment changed.
 #[derive(Debug, Clone, Serialize, Deserialize, Type)]
 #[serde(rename_all = "camelCase")]
@@ -76,7 +72,7 @@ impl Environment {
            return None;
        }
        let config = self.load_project(root, sink);
-        let post_start = config.and_then(|c| c.post_start).filter(|_| std::env::var_os(LIFECYCLE_DONE_ENV).is_none());
+        let post_start = config.and_then(|c| c.post_start);
        let first = self.state.lock().post_started.insert(root.to_path_buf());
        post_start.filter(|_| first)
    }
Author	SHA1	Message	Date
l0ng-ai	434aacc64a	chore(plugins): regenerate bindings on top of main	2026-11-04 02:41:46 +08:00
l0ng-ai	58f8929509	test(plugins): the MyBatis test asks again while the first call builds the index	2026-11-04 02:41:46 +08:00
l0ng-ai	14ddd948f8	test(plugins): capability paths are the platform's in the parse test	2026-11-04 02:41:46 +08:00
l0ng-ai	8df7731fa6	chore(plugins): ide-extension at the workspace version in Cargo.lock	2026-11-04 02:41:46 +08:00
l0ng-ai	20281e9b66	fix(plugins): Windows: local marketplace paths, localhost connections, tests - A marketplace index given as a local Windows path (`C:\market\index.json`) resolves its packages next to it; only URLs are joined with `/`. - HTTP requests to `localhost` try IPv4 loopback first, then IPv6: local servers such as Ollama usually listen on IPv4, and on Windows a refused `::1` cost about two seconds per request. - Tests that assumed Unix: an absolute program path is the platform's, a manifest rewritten by a test may have CRLF line ends, the precompiled-cache test replaces the cache file only after the host that maps it is gone, and the MyBatis test lets its first call build the index before asserting. - The icon theme test's time limits guard against work growing faster than the icon count rather than measure the runner.	2026-11-04 02:41:46 +08:00
l0ng-ai	20960c1d96	fix(plugins): soft deadlines hold under load, unique cache writes, CI on every platform - A provider result produced after its soft deadline is dropped even when it is already waiting (the caller was scheduled late or waited on another plugin first), so the deadline holds on a busy machine. The result is timestamped when the plugin's thread produces it, so a result that came in time is still used when it is read late. - Each precompiled-component write uses its own temporary file: two threads storing the same component could rename a half-written file into place. - Tests: the cache-corruption case replaces the file instead of overwriting the one a running component maps; the yield test no longer counts on a tick rate; a test that runs a shell script is Unix-only like its neighbours. - Plugin web pages declare `@types/node` for their Vite configs instead of finding the repository's.	2026-11-04 02:41:46 +08:00
l0ng-ai	9cc83c77b8	feat(plugins): plugin contributions in the IDE's own settings and menus; official plugins published with releases - Themes: a plugin theme is an `appearance.theme` value (`plugin:<id>/<theme>`), offered by Settings › Appearance (and the preferred themes of Sync with OS), Quick Switch, the toolbar gear menu and Welcome › Customize. The project window selects it in the plugin host; picking a built-in theme clears it. While its plugin is off, the built-in theme of its kind shows and the choice is kept. - File icon themes: chosen in Settings › Appearance › File icon theme and kept in `appearance.fileIconTheme`, so every window follows. - Keymap: plugins' default shortcuts show in Settings › Keymap as the defaults of their actions: removable, changeable, resettable and part of conflict checks. - Problems: a plugin's problems are withdrawn when it stops, fails, is disabled or uninstalled. Settings › Inspections lists them under Plugins by plugin name; stored overrides of `plugin:` producers parse correctly. - Status bar items of plugins are named in the status bar menu and can be hidden. - Languages added or removed by plugins refresh Override File Type, the Code Style pages and Inspections without a restart. - Uninstalling a plugin deletes the secrets it declared. - The Settings window follows plugin changes made elsewhere. - The plugin system is marked Preview (Settings › Plugins, README); Harbor Night is versioned 0.1.0 like the other official plugins. - Release: the official plugins are packed, signed (secret PLUGIN_SIGNING_KEY) and indexed into the release as `plugins-index.json`; released builds use it as the default marketplace. Without the key the step is skipped.	2026-11-04 02:41:46 +08:00
l0ng-ai	ac71b7008e	feat(plugins): Graphviz, Regex Tester, License Header and Harbor Night official plugins - Graphviz: `.dot` / `.gv` files open beside a live preview (a web view rendering with Graphviz compiled to WebAssembly) in any layout engine, with zoom, pan, Fit and SVG / PNG export through the save dialog. What Graphviz reports goes from the page to the plugin's code, which publishes it as problems on the named line. A DOT language, file icons and a New Graphviz Graph template. - Regex Tester: a tool window whose html view sends pattern, flags, text and replacement as you type; the plugin matches with Rust's regex (linear time) and answers with matches, groups and the replacement in UTF-16 offsets. Use Selection and Test Selection take the editor's selection. - License Header: files without a copyright / SPDX header are reported when they open and on save; a quick fix and a command add one in the file's comment syntax (after a shebang or encoding line); a project scan in a background task reports the rest. Holder and license are settings. - Harbor Night becomes an official plugin and the one source of the theme files: `openidea-plugin new --template theme`, the theme docs and tests start from it. - Tool windows' renders and events carry the window's active editor, as commands do, so a view's buttons can act on what the user is editing. - knip leaves plugins' web pages (projects of their own) alone.	2026-11-04 02:41:46 +08:00
l0ng-ai	3b78d15d6d	refactor(plugins): drop the Kubernetes plugin, samples become test fixtures - Remove the Kubernetes official plugin. - `hello` and `language-toy` move from `plugins/` to `crates/ide-plugin/tests/fixtures/`: they stay what the host's tests run against, but are no longer listed as plugins of the repository. - A `jobs` fixture takes over what only Kubernetes exercised: a tree view filled by a pinned program, a terminal for the activated entry in the invoking window, string and number settings, locally and in remote projects. - `plugins/` now holds only the official plugins; `build.sh`, CI and the debug plugin catalog follow.	2026-11-04 02:41:46 +08:00
l0ng-ai	3f52439703	chore(plugins): regenerate bindings and reconcile with main - Regenerated bindings for the merged settings, edits and plugin commands. - Mouse shortcuts run their action through `executeAction` again. - Dropped Chinese entries whose templates main already translates.	2026-11-04 02:41:46 +08:00
l0ng-aiandflorentvdry	a7b7616da9	feat(plugins): install packages from a .zip or a folder's plugin.toml Install Plugin from Package File now takes an `.oiplugin`, a `.zip` or a package folder's `plugin.toml`, and goes through the same install page (capabilities, signature, consent) as every other install. - A zip may hold the package at its root or in its only folder, as zipping the folder makes; archiver metadata (`__MACOSX`, `.DS_Store`, `._*`) is left out. A zip without a `plugin.toml` there, such as an IntelliJ plugin, is refused with a message saying so. Unsafe paths, links and size limits are checked as for `.oiplugin` files. - Picking a `plugin.toml` installs its folder. Co-authored-by: florentvdry <[email protected]>	2026-11-04 02:41:46 +08:00
l0ng-aiandDeng Liu	900f2e6819	feat(plugins): web views, document bridge and the Excalidraw official plugin Plugins can now ship a web page as the UI of a view or custom editor (`web = "web/index.html"`), so editors built on web libraries are plugins rather than part of the core. - Web views: every file under the page's directory is part of the package (checked, copied on install, covered by the digest and signature) and served through the `openidea-plugin` URL scheme, under a per-revision path with a CSP of its own, into an `<iframe sandbox="allow-scripts">`. An update or reinstall reloads open pages. - Frame bridge (`window.openidea`), shared by html bodies and web pages: theme, messages to the plugin's code, `document.get/edit/replace/onChange` (versioned edits that join the text editor's undo history, Save and dirty state), `saveFile`/`openFile` through the IDE's dialogs, and IDE shortcuts the page leaves alone. - Custom editor layouts: tab, split (Editor and X) or preview over the text editor, switchable from the tab's actions. - New points `fileIcons` and `fileTemplates`; new optional capability `clipboard` for web views. - Excalidraw official plugin: `.excalidraw` / `.excalidraw.json` open as an interactive canvas kept in step with the file's text, with self-hosted fonts, PNG/SVG export, images, file icons, a New Drawing template and JSON highlighting. Closes #732. - Fixes: a lock-order deadlock between listing plugins and refreshing project pins; the dev server ignored edits under `src/features/plugins`. - `plugins/build.sh` builds and checks web pages; CI typechecks and tests them. Co-authored-by: Deng Liu <[email protected]>	2026-11-04 02:41:46 +08:00
l0ng-ai	78e0c7a23e	feat(plugins): finalize plugin API before release, concurrent providers Plugin API (breaking; the plugin system is unreleased): - Remove the runtime `contributions` interface (register-command, register-language, register-theme). Commands, languages and themes are declared in plugin.toml only, so everything a plugin contributes goes through the install preview and consent. The registry drops runtime scope, `contribute` and `dispose_runtime`; inline `definition` in language and theme declarations is gone. - `completion-item.kind` is a string (the 25 LSP kinds; unknown kinds show no icon), like the other open-ended kinds. - `lifecycle.activate` and `commands.run` return `types.error` instead of a string. The host maps it to the matching error kind, and only `failed` counts against the plugin: cancelling, a missing grant or an unknown command does not. The SDK's `Plugin` returns `Result<_, Error>`; plain messages convert to `Error::Failed`. Runtime: - Editor providers of several plugins are called at the same time (`Actor::submit` + `Pending::wait`): the wait is the slowest plugin's, not the sum, so each gets the full edit-path budget. Versioning and tooling: - Components are checked at install and by `openidea-plugin check` for the plugin API they were built for; another major or a newer minor is refused with what to do. - Tests: the SDK's WIT matches the host's, a simulated next-minor host links every shipped component, every host function has an SDK wrapper, released APIs only grow (no snapshot until the first release). - plugins/build.sh builds every checked-in component, records a source fingerprint next to it, and `--check` fails on stale components; CI runs it plus fmt, clippy (host and wasm) and tests for the SDK, the official plugins and the fixtures. - The API evolution rules and the checklist for a new host function are in plugins/README.md; the design notes under docs/ are removed.	2026-11-04 02:41:46 +08:00
l0ng-ai	fa003016ef	feat(plugins): theme variables for html view frames, kept current without reload - Inject `data-theme` and stable `--openidea-*` colour and font variables (concrete values; the frame has no IDE stylesheet) into html view bodies. - Post theme changes to the loaded frame instead of rebuilding srcdoc, so a theme switch keeps the frame's state; re-send on load to close the race. - Expose `openidea.theme` / `openidea.onThemeChange` to frame scripts. - Move `subscribeTheme` / `themeKey` from the Markdown mermaid module to `src/platform/themeWatch.ts`, shared by both. - Document the variables in plugins/README.md.	2026-11-04 02:41:46 +08:00
l0ng-ai	fd1f465aeb	feat(plugins): extension points, capability consent, async runtime and plugin API 1.0 Rework the plugin system per docs/plugin_plan.md (P0–P8): - Extension-point registry (ide-extension) so new contribution types register without touching the kernel; languages, run detectors, providers, views and UI contributions go through it. - Per-plugin capability consent with a risk-graded ledger; process capabilities are pinned to resolved binary paths and hashes. - Async, actor-per-plugin Wasm runtime with lazy activation, cancellation, events, long-running tasks and idle reclamation. - Plugin host moved into ide-host, shared by local and remote projects. - Distribution: install/package tooling (openidea-plugin bin) and a static market index. - WIT frozen as openidea:[email protected]; Rust SDK with mock host. - Ten official validation plugins under plugins/official.	2026-11-04 02:41:46 +08:00