feat(plugins): leave room in plugin API 1.0 for what will grow

Released 1.x types never change, so the sets and records that will have to grow are opened up before the API is frozen: - Event kinds and action sources are strings; `event`, view `body`, `view-event` and `field-value` get an `other(extension)` case (a kind and JSON data) that carries later cases to older plugins and IDEs. An IDE refuses an event kind it doesn't know, says a view body needs a newer IDE, and leaves out unknown form fields. - Completion items can be snippets, match on `filter-text` and bring `additional-edits` (imports). Code actions can carry `data` instead of edits; the new `resolve-code-action` export computes them when the user picks the action, under the command budget, through the existing resolve path. - Diagnostics name their `source`, carry `tags` (`unnecessary`, `deprecated`) and `related` locations. - The SDK's enums are `#[non_exhaustive]` with `Other` variants; `Diagnostic::new`, `Providers::resolve_code_action`. - README: 1.x calls stay synchronous and pass documents whole; async and incremental sync come later behind the host adapter or a new interface. Official plugins and fixtures rebuilt.
2026-11-11 02:31:38 -10:00 · 2026-11-04 20:10:09 +08:00
3072 changed files with 23806 additions and 368724 deletions
@@ -3,6 +3,3 @@ contact_links:
  - name: Download the latest release
    url: https://github.com/l0ng-ai/openidea/releases/latest
    about: Many problems are already fixed. Please check the latest version before reporting.
-  - name: Report a security vulnerability
-    url: https://github.com/l0ng-ai/openidea/security/advisories/new
-    about: Please report security problems privately, not in a public issue.
@@ -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" }
@@ -103,16 +56,13 @@ jobs:
        if: runner.os == 'Linux'
        run: git diff --exit-code src/bindings.ts

-  # The remote development server ships as a static Linux binary (release-build.yml):
+  # The remote development server ships as a static Linux binary (release.yml):
  # 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,140 +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
-  INTELEPHENSE: 1.18.5
-
-jobs:
-  smoke:
-    name: Language smoke (${{ matrix.language }})
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [typescript, python, rust, go, java, kotlin, php, c, cpp]
-    # C/C++ debug with GDB, whose DAP interpreter needs 14+: 22.04 ships 12.1, 24.04 ships 15.
-    runs-on: ${{ (matrix.language == 'c' || matrix.language == 'cpp') && 'ubuntu-24.04' || '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"
-
-      # The smoke builds the c-app fixture and debugs it with GDB's own DAP interpreter.
-      - if: matrix.language == 'c' || matrix.language == 'cpp'
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y gdb
-
-      - 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"
-
-      # Xdebug for the debug smoke; Composer installs the fixture's Pest for the run smoke.
-      - if: matrix.language == 'php'
-        uses: shivammathur/setup-php@v2
-        with: { php-version: "8.5", coverage: xdebug, tools: composer }
-      - if: matrix.language == 'php'
-        run: npm install --global "intelephense@$INTELEPHENSE"
-
-      - 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,119 +0,0 @@
-name: Nightly
-
-# Twice a day, builds the newest main commit that passed CI as a prerelease tagged with its own
-# version, so remote development finds the server of that version. The `nightly` release holds
-# the manifest the nightly app updates from; its tag marks the commit last built, and a run with
-# nothing newer stops there. Only the latest builds are kept.
-on:
-  schedule:
-    - cron: "17 2,14 * * *"
-  workflow_dispatch:
-    inputs:
-      force:
-        description: "Build even if nothing is newer than the last nightly"
-        type: boolean
-        default: false
-
-permissions:
-  contents: read
-
-concurrency:
-  group: nightly
-
-env:
-  GH_TOKEN: ${{ github.token }}
-  GH_REPO: ${{ github.repository }}
-
-jobs:
-  prepare:
-    permissions:
-      actions: read
-      contents: write
-    if: github.repository == 'l0ng-ai/openidea'
-    runs-on: ubuntu-latest
-    outputs:
-      sha: ${{ steps.commit.outputs.sha }}
-      tag: ${{ steps.release.outputs.tag }}
-      release_id: ${{ steps.release.outputs.id }}
-    steps:
-      - id: commit
-        env:
-          FORCE: ${{ inputs.force }}
-        run: |
-          sha="$(gh run list --workflow ci.yml --branch main --event push --status success --limit 1 \
-            --json headSha --jq '.[0].headSha // ""')"
-          if [ -z "$sha" ]; then
-            echo "::notice::no main commit has passed CI"
-            exit 0
-          fi
-          # No `nightly` tag yet (the first run): compare fails and the build goes on.
-          status="$(gh api "repos/$GH_REPO/compare/nightly...$sha" --jq .status 2>/dev/null || echo ahead)"
-          if [ "$status" != ahead ] && [ "$FORCE" != true ]; then
-            echo "::notice::$sha is not newer than the last nightly"
-            exit 0
-          fi
-          echo "sha=$sha" >> "$GITHUB_OUTPUT"
-      - uses: actions/checkout@v5
-        if: steps.commit.outputs.sha != ''
-        with: { ref: "${{ steps.commit.outputs.sha }}" }
-      - uses: actions/setup-node@v5
-        if: steps.commit.outputs.sha != ''
-        with: { node-version: 22 }
-      - uses: dtolnay/rust-toolchain@stable
-        if: steps.commit.outputs.sha != ''
-      - id: release
-        if: steps.commit.outputs.sha != ''
-        env:
-          SHA: ${{ steps.commit.outputs.sha }}
-        run: |
-          version="$(node scripts/nightly-prepare.ts "$(date -u +%Y%m%d%H%M)")"
-          tag="v$version"
-          git config user.name "github-actions[bot]"
-          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
-          git commit -am "chore: $tag"
-          git tag "$tag"
-          git push origin "$tag"
-          id="$(gh api -X POST "repos/$GH_REPO/releases" -f tag_name="$tag" -f name="OpenIDEA Nightly $version" \
-            -F draft=true -F prerelease=true -f body="Built from $SHA." --jq .id)"
-          echo "tag=$tag" >> "$GITHUB_OUTPUT"
-          echo "id=$id" >> "$GITHUB_OUTPUT"
-
-  binaries:
-    permissions:
-      contents: write
-    needs: prepare
-    if: needs.prepare.outputs.tag != ''
-    uses: ./.github/workflows/release-build.yml
-    with:
-      tag: ${{ needs.prepare.outputs.tag }}
-      release_id: ${{ needs.prepare.outputs.release_id }}
-    secrets: inherit
-
-  publish:
-    permissions:
-      contents: write
-    needs: [prepare, binaries]
-    runs-on: ubuntu-latest
-    env:
-      TAG: ${{ needs.prepare.outputs.tag }}
-      SHA: ${{ needs.prepare.outputs.sha }}
-      KEEP: 14
-    steps:
-      - name: Publish the build
-        run: gh release edit "$TAG" --tag "$TAG" --draft=false
-      - name: Point the updater at it
-        run: |
-          gh release download "$TAG" -p latest.json -D "$RUNNER_TEMP"
-          gh release view nightly >/dev/null 2>&1 ||
-            gh release create nightly --prerelease --latest=false --target "$SHA" --title "OpenIDEA Nightly" \
-              --notes "The update manifest of the nightly builds, and the commit last built."
-          gh release upload nightly "$RUNNER_TEMP/latest.json" --clobber
-          gh api -X PATCH "repos/$GH_REPO/git/refs/tags/nightly" -f sha="$SHA" -F force=true --silent
-      # Failed builds' drafts go too, once they are this old.
-      - name: Delete old builds
-        run: |
-          gh release list --limit 200 --json tagName,createdAt --jq \
-            '[.[] | select(.tagName | contains("-nightly."))] | sort_by(.createdAt) | reverse | .[env.KEEP | tonumber:][].tagName' |
-            while read -r tag; do
-              gh release delete "$tag" --cleanup-tag --yes
-            done
@@ -22,8 +22,6 @@ env:

 jobs:
  merge:
-    # The schedule is for this repository's release; forks can still run it by hand.
-    if: github.event_name != 'schedule' || github.repository == 'l0ng-ai/openidea'
    runs-on: ubuntu-latest
    steps:
      - name: Merge the community index
@@ -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.');
@@ -1,283 +0,0 @@
-name: Release build
-
-# Builds a tag's desktop apps, remote servers and updater manifest into its draft release.
-# Stable releases (release.yml) and nightly builds (nightly.yml) both run it.
-on:
-  workflow_call:
-    inputs:
-      tag: { type: string, required: true }
-      release_id: { type: string, required: true }
-
-permissions:
-  contents: read
-
-env:
-  CARGO_TERM_COLOR: always
-  CARGO_INCREMENTAL: 0
-  TAG: ${{ inputs.tag }}
-
-jobs:
-  plugin-keys:
-    permissions: {}
-    runs-on: ubuntu-latest
-    outputs:
-      keys: ${{ steps.keys.outputs.keys }}
-    steps:
-      # 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: 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
-
-  build:
-    permissions:
-      contents: write
-    needs: plugin-keys
-    name: Build (${{ matrix.name }})
-    env:
-      OPENIDEA_OFFICIAL_PLUGIN_KEYS: ${{ needs.plugin-keys.outputs.keys }}
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - name: macOS arm64
-            os: macos-latest
-            target: aarch64-apple-darwin
-          - name: macOS x64
-            os: macos-latest
-            target: x86_64-apple-darwin
-          - name: Linux x64
-            os: ubuntu-22.04
-            target: x86_64-unknown-linux-gnu
-          - name: Linux arm64
-            os: ubuntu-22.04-arm
-            target: aarch64-unknown-linux-gnu
-          - name: Windows arm64
-            os: windows-11-arm
-            target: aarch64-pc-windows-msvc
-          - name: Windows x64
-            os: windows-latest
-            target: x86_64-pc-windows-msvc
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v5
-        with: { ref: "${{ env.TAG }}" }
-      - uses: pnpm/action-setup@v5
-        with: { version: 11 }
-      - uses: actions/setup-node@v5
-        with: { node-version: 22, cache: pnpm }
-      - uses: dtolnay/rust-toolchain@stable
-        with: { targets: "${{ matrix.target }}" }
-      - uses: Swatinem/rust-cache@v2
-        with: { key: "${{ matrix.target }}" }
-      - name: Linux deps
-        if: runner.os == 'Linux'
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev libxdo-dev libssl-dev patchelf
-      - run: pnpm install --frozen-lockfile
-      # Signing is optional: only secrets that are set get exported, so forks and
-      # unconfigured repos produce unsigned builds instead of failing.
-      - name: Signing env
-        shell: bash
-        env:
-          APPLE_CERTIFICATE: ${{ runner.os == 'macOS' && secrets.APPLE_CERTIFICATE || '' }}
-          APPLE_CERTIFICATE_PASSWORD: ${{ runner.os == 'macOS' && secrets.APPLE_CERTIFICATE_PASSWORD || '' }}
-          APPLE_SIGNING_IDENTITY: ${{ runner.os == 'macOS' && secrets.APPLE_SIGNING_IDENTITY || '' }}
-          APPLE_ID: ${{ runner.os == 'macOS' && secrets.APPLE_ID || '' }}
-          APPLE_PASSWORD: ${{ runner.os == 'macOS' && secrets.APPLE_PASSWORD || '' }}
-          APPLE_TEAM_ID: ${{ runner.os == 'macOS' && secrets.APPLE_TEAM_ID || '' }}
-          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
-          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
-        run: |
-          for v in APPLE_CERTIFICATE APPLE_CERTIFICATE_PASSWORD APPLE_SIGNING_IDENTITY APPLE_ID \
-                   APPLE_PASSWORD APPLE_TEAM_ID TAURI_SIGNING_PRIVATE_KEY TAURI_SIGNING_PRIVATE_KEY_PASSWORD; do
-            [ -n "${!v}" ] && { echo "$v<<__EOF__"; echo "${!v}"; echo "__EOF__"; } >> "$GITHUB_ENV"
-          done
-          true
-      - uses: tauri-apps/tauri-action@v0
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          releaseId: ${{ inputs.release_id }}
-          tagName: ${{ env.TAG }}
-          args: --target ${{ matrix.target }}
-          # The parallel builds would race on one latest.json; `updater-manifest` writes it once.
-          uploadUpdaterJson: false
-      # tauri-action notarizes the .app but not the DMG around it; notarize and
-      # staple the DMG too, then replace the uploaded asset.
-      - name: Notarize DMG
-        if: runner.os == 'macOS' && env.APPLE_ID != ''
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          for dmg in target/${{ matrix.target }}/release/bundle/dmg/*.dmg; do
-            xcrun notarytool submit "$dmg" --apple-id "$APPLE_ID" --password "$APPLE_PASSWORD" \
-              --team-id "$APPLE_TEAM_ID" --wait
-            xcrun stapler staple "$dmg"
-            # Release assets have no spaces: GitHub stored the first upload with dots.
-            asset="$RUNNER_TEMP/$(basename "$dmg" | tr ' ' .)"
-            cp "$dmg" "$asset"
-            gh release upload "$TAG" "$asset" --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.
-  # Linux builds are static (musl), so they run whatever the host's glibc.
-  server:
-    permissions:
-      contents: write
-    name: Server (${{ matrix.os }}-${{ matrix.arch }})
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - { runner: ubuntu-22.04, target: x86_64-unknown-linux-musl, os: linux, arch: x86_64 }
-          - { runner: ubuntu-24.04-arm, target: aarch64-unknown-linux-musl, os: linux, arch: aarch64 }
-          - { runner: macos-latest, target: aarch64-apple-darwin, os: macos, arch: aarch64 }
-          - { runner: macos-latest, target: x86_64-apple-darwin, os: macos, arch: x86_64 }
-    runs-on: ${{ matrix.runner }}
-    steps:
-      - uses: actions/checkout@v5
-        with: { ref: "${{ env.TAG }}" }
-      - uses: dtolnay/rust-toolchain@stable
-        with: { targets: "${{ matrix.target }}" }
-      - uses: Swatinem/rust-cache@v2
-        with: { key: "server-${{ matrix.target }}" }
-      - name: musl toolchain
-        if: runner.os == 'Linux'
-        run: sudo apt-get update && sudo apt-get install -y musl-tools
-      - name: Build
-        run: |
-          # musl-tools only ships `musl-gcc`; cc-rs would look for `<arch>-linux-musl-gcc`.
-          if [ "$RUNNER_OS" = Linux ]; then export CC_${TARGET//-/_}=musl-gcc; fi
-          cargo build --release --locked -p ide-host --bin openidea-server --target "$TARGET"
-        env:
-          TARGET: ${{ matrix.target }}
-      - name: Upload
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          ASSET: openidea-server-${{ matrix.os }}-${{ matrix.arch }}.gz
-        run: |
-          gzip -9 -c target/${{ matrix.target }}/release/openidea-server > "$ASSET"
-          if command -v sha256sum >/dev/null; then sha256sum "$ASSET"; else shasum -a 256 "$ASSET"; fi > "$ASSET.sha256"
-          gh release upload "$TAG" "$ASSET" "$ASSET.sha256" --clobber
-
-  # The updater manifest (latest.json), built once from the signed bundles every build uploaded.
-  # Fails when a platform is missing, so a release never ships a manifest without it.
-  updater-manifest:
-    permissions:
-      contents: write
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/github-script@v8
-        env:
-          RELEASE_ID: ${{ inputs.release_id }}
-        with:
-          script: |
-            const { owner, repo } = context.repo;
-            const release_id = Number(process.env.RELEASE_ID);
-            const tag = process.env.TAG;
-            const assets = await github.paginate(github.rest.repos.listReleaseAssets, { owner, repo, release_id });
-            const sigs = assets.filter((a) => a.name.endsWith(".sig"));
-            if (sigs.length === 0) {
-              core.notice("no signed bundles (TAURI_SIGNING_PRIVATE_KEY unset): skipping latest.json");
-              return;
-            }
-            // Bundle suffix → updater platform keys, as tauri-action names them.
-            // Nightly versions don't fit MSI or RPM, so those builds offer NSIS on Windows.
-            const nightly = tag.includes("-nightly.");
-            const windows = (arch, msi, nsis) => nightly
-              ? [[nsis, [`windows-${arch}`, `windows-${arch}-nsis`]]]
-              : [[msi, [`windows-${arch}`, `windows-${arch}-msi`]], [nsis, [`windows-${arch}-nsis`]]];
-            const kinds = [
-              [/_aarch64\.AppImage$/, ["linux-aarch64", "linux-aarch64-appimage"]],
-              [/_arm64\.deb$/, ["linux-aarch64-deb"]],
-              ...(nightly ? [] : [[/\.aarch64\.rpm$/, ["linux-aarch64-rpm"]]]),
-              [/_amd64\.AppImage$/, ["linux-x86_64", "linux-x86_64-appimage"]],
-              [/_amd64\.deb$/, ["linux-x86_64-deb"]],
-              ...(nightly ? [] : [[/\.x86_64\.rpm$/, ["linux-x86_64-rpm"]]]),
-              [/_aarch64\.app\.tar\.gz$/, ["darwin-aarch64", "darwin-aarch64-app"]],
-              [/_x64\.app\.tar\.gz$/, ["darwin-x86_64", "darwin-x86_64-app"]],
-              ...windows("aarch64", /_arm64_en-US\.msi$/, /_arm64-setup\.exe$/),
-              ...windows("x86_64", /_x64_en-US\.msi$/, /_x64-setup\.exe$/),
-            ];
-            const platforms = {};
-            for (const sig of sigs) {
-              const bundle = sig.name.slice(0, -".sig".length);
-              const kind = kinds.find(([re]) => re.test(bundle));
-              if (!kind) continue;
-              const { data } = await github.rest.repos.getReleaseAsset({
-                owner, repo, asset_id: sig.id, headers: { accept: "application/octet-stream" },
-              });
-              const signature = Buffer.from(data).toString("utf8").trim();
-              const url = `https://github.com/${owner}/${repo}/releases/download/${tag}/${encodeURIComponent(bundle)}`;
-              for (const key of kind[1]) platforms[key] = { signature, url };
-            }
-            const missing = kinds.flatMap(([, keys]) => keys).filter((k) => !platforms[k]);
-            if (missing.length) {
-              core.setFailed(`latest.json would miss ${missing.join(", ")}`);
-              return;
-            }
-            // The update's notes: the release body without its Download section. That
-            // section only matters on the release page, and What's new follows it.
-            const { data: release } = await github.rest.repos.getRelease({ owner, repo, release_id });
-            const withoutDownloadSection = (body) => {
-              const kept = [];
-              let skip = 0;
-              for (const line of body.split(/\r?\n/)) {
-                const heading = /^(#{1,6})\s+(.*)$/.exec(line);
-                if (heading) {
-                  const level = heading[1].length;
-                  if (!skip && level <= 3 && /^download$/i.test(heading[2].trim())) {
-                    skip = level;
-                    continue;
-                  }
-                  if (skip && level <= skip) skip = 0;
-                }
-                if (!skip) kept.push(line);
-              }
-              return kept.join("\n").trim();
-            };
-            const notes = withoutDownloadSection(String(release.body ?? ""));
-            const manifest = { version: tag.replace(/^v/, ""), notes, pub_date: new Date().toISOString(), platforms };
-            const old = assets.find((a) => a.name === "latest.json");
-            if (old) await github.rest.repos.deleteReleaseAsset({ owner, repo, asset_id: old.id });
-            await github.rest.repos.uploadReleaseAsset({
-              owner, repo, release_id, name: "latest.json",
-              data: JSON.stringify(manifest, null, 2),
-              headers: { "content-type": "application/json" },
-            });
-            core.info(`latest.json: ${Object.keys(platforms).sort().join(", ")}`);
@@ -1,7 +1,7 @@
 name: Release
 on:
  push:
-    tags: ["v*", "!v*-nightly.*"]
+    tags: ["v*"]
  workflow_dispatch:
    inputs:
      tag:
@@ -9,7 +9,7 @@ on:
        required: true

 permissions:
-  contents: read
+  contents: write

 concurrency:
  group: release-${{ github.event.inputs.tag || github.ref_name }}
@@ -23,14 +23,12 @@ env:
 jobs:
  # Creates (or reuses) one draft release that every platform build uploads into.
  create-release:
-    if: ${{ !contains(github.event.inputs.tag || github.ref_name, '-nightly.') }}
-    permissions:
-      contents: write
    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: |
@@ -39,18 +37,22 @@ 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/
+      # 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: |
-          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
+          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;
@@ -62,26 +64,139 @@ jobs:
              core.setOutput("id", existing.id);
              return;
            }
-            // Nightly builds are prereleases: the notes span stable release to stable release.
-            const previous = releases.find((r) => !r.draft && !r.prerelease);
-            const { data: notes } = await github.rest.repos.generateReleaseNotes({
-              owner, repo, tag_name: tag, previous_tag_name: previous?.tag_name,
-            });
            const { data } = await github.rest.repos.createRelease({
              owner, repo, tag_name: tag, name: `OpenIDEA ${tag}`,
-              draft: true, prerelease: tag.includes("-"), body: notes.body,
+              draft: true, prerelease: tag.includes("-"), generate_release_notes: true,
            });
            core.setOutput("id", data.id);

-  binaries:
-    permissions:
-      contents: write
+  build:
    needs: create-release
-    uses: ./.github/workflows/release-build.yml
-    with:
-      tag: ${{ github.event.inputs.tag || github.ref_name }}
-      release_id: ${{ needs.create-release.outputs.release_id }}
-    secrets: inherit
+    name: Build (${{ matrix.name }})
+    env:
+      OPENIDEA_OFFICIAL_PLUGIN_KEYS: ${{ needs.create-release.outputs.official_plugin_keys }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: macOS arm64
+            os: macos-latest
+            target: aarch64-apple-darwin
+          - name: macOS x64
+            os: macos-latest
+            target: x86_64-apple-darwin
+          - name: Linux x64
+            os: ubuntu-22.04
+            target: x86_64-unknown-linux-gnu
+          - name: Linux arm64
+            os: ubuntu-22.04-arm
+            target: aarch64-unknown-linux-gnu
+          - name: Windows arm64
+            os: windows-11-arm
+            target: aarch64-pc-windows-msvc
+          - name: Windows x64
+            os: windows-latest
+            target: x86_64-pc-windows-msvc
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+        with: { ref: "${{ env.TAG }}" }
+      - uses: pnpm/action-setup@v4
+        with: { version: 11 }
+      - uses: actions/setup-node@v4
+        with: { node-version: 22, cache: pnpm }
+      - uses: dtolnay/rust-toolchain@stable
+        with: { targets: "${{ matrix.target }}" }
+      - uses: Swatinem/rust-cache@v2
+        with: { key: "${{ matrix.target }}" }
+      - name: Linux deps
+        if: runner.os == 'Linux'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev libxdo-dev libssl-dev patchelf
+      - run: pnpm install --frozen-lockfile
+      # Signing is optional: only secrets that are set get exported, so forks and
+      # unconfigured repos produce unsigned builds instead of failing.
+      - name: Signing env
+        shell: bash
+        env:
+          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
+          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+          APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_SIGNING_IDENTITY }}
+          APPLE_ID: ${{ secrets.APPLE_ID }}
+          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
+          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
+          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
+          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
+        run: |
+          for v in APPLE_CERTIFICATE APPLE_CERTIFICATE_PASSWORD APPLE_SIGNING_IDENTITY APPLE_ID \
+                   APPLE_PASSWORD APPLE_TEAM_ID TAURI_SIGNING_PRIVATE_KEY TAURI_SIGNING_PRIVATE_KEY_PASSWORD; do
+            [ -n "${!v}" ] && { echo "$v<<__EOF__"; echo "${!v}"; echo "__EOF__"; } >> "$GITHUB_ENV"
+          done
+          true
+      - uses: tauri-apps/tauri-action@v0
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          releaseId: ${{ needs.create-release.outputs.release_id }}
+          tagName: ${{ env.TAG }}
+          args: --target ${{ matrix.target }}
+          # The parallel builds would race on one latest.json; `updater-manifest` writes it once.
+          uploadUpdaterJson: false
+      # tauri-action notarizes the .app but not the DMG around it; notarize and
+      # staple the DMG too, then replace the uploaded asset.
+      - name: Notarize DMG
+        if: runner.os == 'macOS' && env.APPLE_ID != ''
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          for dmg in target/${{ matrix.target }}/release/bundle/dmg/*.dmg; do
+            xcrun notarytool submit "$dmg" --apple-id "$APPLE_ID" --password "$APPLE_PASSWORD" \
+              --team-id "$APPLE_TEAM_ID" --wait
+            xcrun stapler staple "$dmg"
+            gh release upload "$TAG" "$dmg" --clobber
+          done
+
+  # 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.
+  # Linux builds are static (musl), so they run whatever the host's glibc.
+  server:
+    needs: create-release
+    name: Server (${{ matrix.os }}-${{ matrix.arch }})
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { runner: ubuntu-22.04, target: x86_64-unknown-linux-musl, os: linux, arch: x86_64 }
+          - { runner: ubuntu-24.04-arm, target: aarch64-unknown-linux-musl, os: linux, arch: aarch64 }
+          - { runner: macos-latest, target: aarch64-apple-darwin, os: macos, arch: aarch64 }
+          - { runner: macos-latest, target: x86_64-apple-darwin, os: macos, arch: x86_64 }
+    runs-on: ${{ matrix.runner }}
+    steps:
+      - uses: actions/checkout@v4
+        with: { ref: "${{ env.TAG }}" }
+      - uses: dtolnay/rust-toolchain@stable
+        with: { targets: "${{ matrix.target }}" }
+      - uses: Swatinem/rust-cache@v2
+        with: { key: "server-${{ matrix.target }}" }
+      - name: musl toolchain
+        if: runner.os == 'Linux'
+        run: sudo apt-get update && sudo apt-get install -y musl-tools
+      - name: Build
+        run: |
+          # musl-tools only ships `musl-gcc`; cc-rs would look for `<arch>-linux-musl-gcc`.
+          if [ "$RUNNER_OS" = Linux ]; then export CC_${TARGET//-/_}=musl-gcc; fi
+          cargo build --release --locked -p ide-host --bin openidea-server --target "$TARGET"
+        env:
+          TARGET: ${{ matrix.target }}
+      - name: Upload
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          ASSET: openidea-server-${{ matrix.os }}-${{ matrix.arch }}.gz
+        run: |
+          gzip -9 -c target/${{ matrix.target }}/release/openidea-server > "$ASSET"
+          if command -v sha256sum >/dev/null; then sha256sum "$ASSET"; else shasum -a 256 "$ASSET"; fi > "$ASSET.sha256"
+          gh release upload "$TAG" "$ASSET" "$ASSET.sha256" --clobber

  # The official plugins, signed, and the marketplace index released apps read
  # (releases/latest/download/plugins-index.json). They are not in the
@@ -93,8 +208,6 @@ jobs:
  # openidea-plugin tool for Linux x64, which that workflow and the registry's
  # checks run.
  plugins:
-    permissions:
-      contents: write
    needs: create-release
    name: Official plugins
    runs-on: ubuntu-22.04
@@ -107,7 +220,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
@@ -116,10 +229,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.
@@ -158,13 +271,73 @@ jobs:
          gh release upload "$TAG" "$out"/*.oiplugin "$out/plugins-index.json" \
            "$out/openidea-plugin-linux-x86_64.gz" --clobber

-  publish:
-    permissions:
-      contents: write
-    needs: [create-release, binaries, plugins]
+  # The updater manifest (latest.json), built once from the signed bundles every build uploaded.
+  # Fails when a platform is missing, so a release never ships a manifest without it.
+  updater-manifest:
+    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:
+          script: |
+            const { owner, repo } = context.repo;
+            const release_id = Number(process.env.RELEASE_ID);
+            const tag = process.env.TAG;
+            const assets = await github.paginate(github.rest.repos.listReleaseAssets, { owner, repo, release_id });
+            const sigs = assets.filter((a) => a.name.endsWith(".sig"));
+            if (sigs.length === 0) {
+              core.notice("no signed bundles (TAURI_SIGNING_PRIVATE_KEY unset): skipping latest.json");
+              return;
+            }
+            // Bundle suffix → updater platform keys, as tauri-action names them.
+            const kinds = [
+              [/_aarch64\.AppImage$/, ["linux-aarch64", "linux-aarch64-appimage"]],
+              [/_arm64\.deb$/, ["linux-aarch64-deb"]],
+              [/\.aarch64\.rpm$/, ["linux-aarch64-rpm"]],
+              [/_amd64\.AppImage$/, ["linux-x86_64", "linux-x86_64-appimage"]],
+              [/_amd64\.deb$/, ["linux-x86_64-deb"]],
+              [/\.x86_64\.rpm$/, ["linux-x86_64-rpm"]],
+              [/_aarch64\.app\.tar\.gz$/, ["darwin-aarch64", "darwin-aarch64-app"]],
+              [/_x64\.app\.tar\.gz$/, ["darwin-x86_64", "darwin-x86_64-app"]],
+              [/_arm64_en-US\.msi$/, ["windows-aarch64", "windows-aarch64-msi"]],
+              [/_arm64-setup\.exe$/, ["windows-aarch64-nsis"]],
+              [/_x64_en-US\.msi$/, ["windows-x86_64", "windows-x86_64-msi"]],
+              [/_x64-setup\.exe$/, ["windows-x86_64-nsis"]],
+            ];
+            const platforms = {};
+            for (const sig of sigs) {
+              const bundle = sig.name.slice(0, -".sig".length);
+              const kind = kinds.find(([re]) => re.test(bundle));
+              if (!kind) continue;
+              const { data } = await github.rest.repos.getReleaseAsset({
+                owner, repo, asset_id: sig.id, headers: { accept: "application/octet-stream" },
+              });
+              const signature = Buffer.from(data).toString("utf8").trim();
+              const url = `https://github.com/${owner}/${repo}/releases/download/${tag}/${encodeURIComponent(bundle)}`;
+              for (const key of kind[1]) platforms[key] = { signature, url };
+            }
+            const missing = kinds.flatMap(([, keys]) => keys).filter((k) => !platforms[k]);
+            if (missing.length) {
+              core.setFailed(`latest.json would miss ${missing.join(", ")}`);
+              return;
+            }
+            const manifest = { version: tag.replace(/^v/, ""), notes: "", pub_date: new Date().toISOString(), platforms };
+            const old = assets.find((a) => a.name === "latest.json");
+            if (old) await github.rest.repos.deleteReleaseAsset({ owner, repo, asset_id: old.id });
+            await github.rest.repos.uploadReleaseAsset({
+              owner, repo, release_id, name: "latest.json",
+              data: JSON.stringify(manifest, null, 2),
+              headers: { "content-type": "application/json" },
+            });
+            core.info(`latest.json: ${Object.keys(platforms).sort().join(", ")}`);
+
+  publish:
+    needs: [create-release, build, server, plugins, updater-manifest]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/github-script@v7
        env:
          RELEASE_ID: ${{ needs.create-release.outputs.release_id }}
        with:
@@ -172,10 +345,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,8 +11,7 @@
    "src/bindings.ts",
    "src/editor/core/cm/angular/parser*.ts",
    "src/editor/core/cm/jsp/parser*.ts",
-    "src/editor/core/cm/astro/parser*.ts",
-    "plugins/themes.md",
+    "docs/plugins/themes.md",
    "pnpm-lock.yaml",
    "**/*.toml",
    "fixtures",
@@ -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,16 +18,11 @@ 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`, `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.
- `docs/` — the Mintlify documentation site (`docs.json` navigation, `en/` and `zh/` pages);
-  preview with `npx mint dev` in `docs/`.

 ## Rules

@@ -51,10 +46,9 @@ Visual style: dark, low-contrast greys, one cool accent

 ## 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
@@ -70,19 +64,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

@@ -126,8 +111,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,9 +26,8 @@ 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.

@@ -36,4 +36,5 @@ 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.42"
+version = "0.1.35"
 edition = "2024"
 rust-version = "1.96"
 license = "Apache-2.0"
@@ -42,16 +42,9 @@ ide-fonts = { path = "crates/ide-fonts" }
 ide-ssh = { path = "crates/ide-ssh" }
 ide-remote = { path = "crates/ide-remote" }
 ide-host = { path = "crates/ide-host" }
-ide-mcp = { path = "crates/ide-mcp" }
-ide-scaffold = { path = "crates/ide-scaffold" }
 ide-notebook = { path = "crates/ide-notebook" }
 ide-extension = { path = "crates/ide-extension" }
 ide-plugin = { path = "crates/ide-plugin" }
-ide-cli = { path = "crates/ide-cli" }
-ide-jvm-attach = { path = "crates/ide-jvm-attach" }
-ide-jvm-inspect = { path = "crates/ide-jvm-inspect" }
-ide-jdwp = { path = "crates/ide-jdwp" }
-ide-heap = { path = "crates/ide-heap" }

 # serialization & IPC typing
 serde = { version = "1", features = ["derive"] }
@@ -83,12 +76,12 @@ ignore = "0.4"
 base64 = "0.22"
 globset = "0.4"
 notify = "8"
+notify-debouncer-full = "0.6"
 trash = "5"
 blake3 = "1"
 dunce = "1"
 dirs = "6"
-memmap2 = "0.9"
-zip = { version = "9.2.3", default-features = false, features = ["deflate"] }
+zip = { version = "9", default-features = false, features = ["deflate"] }

 # search, index, language
 grep-searcher = "0.1"
@@ -109,16 +102,10 @@ portable-pty = "0.9"
 reqwest = { version = "0.13", default-features = false, features = ["rustls-no-provider", "http2", "charset", "socks", "gzip", "deflate", "brotli"] }
 rustls = { version = "0.23", default-features = false, features = ["ring", "std", "tls12", "logging"] }
 rustls-platform-verifier = "0.7"
-# Until SQLx releases its libsqlite3-sys 0.39 update (RUSTSEC-2026-0459).
-sqlx = { version = "0.9", git = "https://github.com/transact-rs/sqlx", rev = "10462fa4414c6c7f1ed1d39bb31678e3b726878c", default-features = false, features = ["runtime-tokio", "tls-rustls-ring-webpki", "sqlite", "postgres", "mysql"] }
+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"] }
-# Pure-Rust thin Oracle driver; pinned to the beta until it stabilizes.
-oracledb = "=26.0.0-beta.5"
 bb8 = "0.9"
 uuid = { version = "1", features = ["v4"] }
-# OS credential stores
-keyring = "4.2"
-keyring-core = "1"

 # testing
 insta = { version = "1", features = ["yaml"] }
@@ -128,20 +115,12 @@ 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
-# Thin LTO: fat LTO's whole-program link outgrew the 16 GB release runners
-# (Linux arm64 was killed mid-link from v0.1.39 on).
-lto = "thin"
+lto = true
 opt-level = 3
 # Unwind, so a panic fails one task or command instead of quitting the IDE.
 panic = "unwind"
@@ -12,13 +12,9 @@
 <p align="center">
  <a href="https://github.com/l0ng-ai/openidea/releases/latest"><b>Download</b></a>
  &nbsp;·&nbsp;
-  <a href="https://openidea.sh">Docs</a>
-  &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
@@ -49,25 +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](https://openidea.sh/en/plugins) 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=".github/assets/wechat-group.png" alt="WeChat group QR code" width="200">
-
- Contributing: see [CONTRIBUTING.md](CONTRIBUTING.md) and the [contributor docs](https://openidea.sh/en/contribute/setup).
-
 ## License

 [Apache 2.0](LICENSE). Bundled third-party assets are listed in [`THIRD_PARTY_LICENSES.md`](THIRD_PARTY_LICENSES.md).
@@ -1,26 +0,0 @@
-# Security policy
-
-## Reporting a vulnerability
-
-Please do not report security problems in public issues, pull requests or discussions.
-
-Report them privately through GitHub:
-[Report a vulnerability](https://github.com/l0ng-ai/openidea/security/advisories/new)
-(repository **Security** tab → **Report a vulnerability**). Only the maintainers can see
-the report.
-
-Include what you can of:
-
- the affected version, platform, and whether remote development (`openidea-server`)
-  or plugins are involved;
- steps to reproduce, or a proof of concept;
- the impact you expect, and any fix you suggest.
-
-We will acknowledge the report, keep you updated in the advisory, and agree on a
-disclosure date with you. Fixes are released as a new version, and the advisory is
-published once users can update.
-
-## Supported versions
-
-Security fixes go into the latest release. Please check that the problem still occurs
-there before reporting.
@@ -1,20 +1,13 @@
 # Third-party licenses

-## Project type icons
-
-`src/ui/brands/*.svg` use the unmodified logo paths from
-[Simple Icons](https://github.com/simple-icons/simple-icons), retrieved through
-Iconify (`simple-icons:angular`, `simple-icons:astro`, `simple-icons:cplusplus`, `simple-icons:dart`, `simple-icons:django`, `simple-icons:dotnet`, `simple-icons:elixir`, `simple-icons:express`, `simple-icons:fastapi`, `simple-icons:flask`, `simple-icons:flutter`, `simple-icons:go`, `simple-icons:haskell`, `simple-icons:html5`, `simple-icons:kotlin`, `simple-icons:ktor`, `simple-icons:laravel`, `simple-icons:nestjs`, `simple-icons:nextdotjs`, `simple-icons:nodedotjs`, `simple-icons:nuxt`, `simple-icons:openjdk`, `simple-icons:phoenixframework`, `simple-icons:php`, `simple-icons:python`, `simple-icons:quarkus`, `simple-icons:ruby`, `simple-icons:rubyonrails`, `simple-icons:rust`, `simple-icons:scala`, `simple-icons:springboot`, `simple-icons:svelte`, `simple-icons:swift`, `simple-icons:symfony`, `simple-icons:vite`, `simple-icons:zig`) and filled with the brand colors (the standard icon grey for black logos). Licensed under [CC0 1.0 Universal](https://github.com/simple-icons/simple-icons/blob/develop/LICENSE.md).
-
 ## 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

@@ -40,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
@@ -60,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
@@ -268,7 +251,7 @@ END OF TERMS AND CONDITIONS

 The Solarized palettes in `src/styles/tokens.css` are adapted from
 [Ethan Schoonover’s Solarized](https://github.com/altercation/solarized/tree/62f656a02f93c5190a8753159e34b385588d5ff3).
-MIT license:
+See [theme sources and mapping](docs/themes.md). MIT license:

 ```text
 Copyright (c) 2011 Ethan Schoonover
@@ -296,11 +279,7 @@ THE SOFTWARE.

 The One palettes and semantic syntax mapping in `src/styles/tokens.css` are
 adapted from GitHub’s Atom One syntax and UI themes.
-Source revisions:
-[one-light-syntax d845790](https://github.com/atom/one-light-syntax/tree/d84579027410c576086dfca14d934c4bd74b0438),
-[one-dark-syntax 9c96f44](https://github.com/atom/one-dark-syntax/tree/9c96f4454362267ac45322063e193ccf9d2debb1),
-[one-light-ui a27bce3](https://github.com/atom/one-light-ui/tree/a27bce35088ecd323e44f5c2510bcf2d4e9efcf8),
-[one-dark-ui 18c2143](https://github.com/atom/one-dark-ui/tree/18c2143d41e17b337fff6dc7024562c4d999be17).
+Source revisions are listed in [theme sources and mapping](docs/themes.md).
 Both syntax themes use the following MIT notice:

 ```text
@@ -9,7 +9,6 @@ license.workspace = true
 encoding_rs.workspace = true
 ide-vfs.workspace = true
 ide-core.workspace = true
-ide-mcp.workspace = true
 ide-jsonrpc.workspace = true
 ide-vcs.workspace = true
 ide-tools = { path = "../ide-tools" }
@@ -22,5 +21,7 @@ tracing.workspace = true
 parking_lot.workspace = true
 dunce.workspace = true
 uuid.workspace = true
-tempfile.workspace = true
 which = "8"
+
+[dev-dependencies]
+tempfile.workspace = true
@@ -27,29 +27,6 @@ use std::sync::Arc;
 use std::sync::atomic::{AtomicU8, Ordering};
 use tokio::sync::oneshot;

-/// ACP's error code for a request that needs the user to sign in.
-pub(crate) const AUTH_REQUIRED: i64 = -32000;
-
-// Covers signed-out users and refused accounts (Claude Code: "API Error: 403").
-pub(crate) fn auth_required(code: i64, message: &str) -> bool {
-    if code == AUTH_REQUIRED {
-        return true;
-    }
-    let lower = message.to_lowercase();
-    let words: Vec<&str> = lower.split(|c: char| !c.is_alphanumeric()).filter(|w| !w.is_empty()).collect();
-    words.iter().any(|w| {
-        *w == "auth"
-            || w.starts_with("authenticat")
-            || w.starts_with("authoriz")
-            || w.starts_with("unauthenticat")
-            || w.starts_with("unauthoriz")
-            || w.starts_with("oauth")
-    }) || words.windows(3).any(|w| w == ["not", "logged", "in"])
-        || words
-            .windows(2)
-            .any(|w| w == ["logged", "out"] || w == ["sign", "in"] || w == ["log", "in"] || w == ["login", "required"])
-}
-
 /// The capabilities this client offers, in v1 form.
 fn client_capabilities() -> Value {
    json!({
@@ -92,11 +69,6 @@ pub(crate) struct Negotiated {
 }

 impl Negotiated {
-    pub fn mcp_stdio(&self) -> bool {
-        // Stdio is the ACP v1 baseline; v2 negotiates each transport explicitly.
-        self.capabilities.pointer("/mcpCapabilities/stdio").and_then(Value::as_bool).unwrap_or(self.generation == 1)
-    }
-
    /// Reads an `initialize` response. The shape decides, not `protocolVersion`: some v1
    /// agents report version 2 with v1 fields (`agentInfo`, `agentCapabilities`); only a
    /// v2 response has `info`.
@@ -125,7 +97,7 @@ impl Negotiated {
                "audio": has(prompt, "audio"),
                "embeddedContext": has(prompt, "embeddedContext"),
            },
-            "mcpCapabilities": { "http": has(mcp, "http"), "sse": false, "stdio": has(mcp, "stdio") },
+            "mcpCapabilities": { "http": has(mcp, "http"), "sse": false },
        });
        if session.is_some() {
            let mut sc = json!({ "list": {}, "resume": {}, "close": {} });
@@ -164,11 +136,6 @@ impl Negotiated {
        self.capabilities.pointer(&format!("/promptCapabilities/{name}")).and_then(Value::as_bool) == Some(true)
    }

-    /// `mcpCapabilities.<name>` (`http`, `sse`).
-    pub fn mcp(&self, name: &str) -> bool {
-        self.capabilities.pointer(&format!("/mcpCapabilities/{name}")).and_then(Value::as_bool) == Some(true)
-    }
-
    /// `sessionCapabilities.<name>` (`fork`, `resume`, `close`, `list`, `delete`).
    pub fn session(&self, name: &str) -> bool {
        self.capabilities.pointer(&format!("/sessionCapabilities/{name}")).is_some_and(|v| !v.is_null())
@@ -178,17 +145,6 @@ impl Negotiated {
    pub fn meta(&self, pointer: &str) -> Option<&Value> {
        self.capabilities.get("_meta")?.pointer(pointer)
    }
-
-    /// First authentication method the agent can run over ACP (`type` absent or `"agent"`).
-    pub fn agent_auth_method(&self) -> Option<&str> {
-        self.auth_methods.iter().find_map(|m| {
-            let kind = m.get("type").and_then(Value::as_str).unwrap_or("agent");
-            (kind == "agent" && m.pointer("/_meta/terminal-auth").is_none())
-                .then(|| m.get("id").and_then(Value::as_str))
-                .flatten()
-                .filter(|id| !id.is_empty())
-        })
-    }
 }

 /// The client side of one agent connection: wraps the task's [`Handler`] and, once
@@ -16,42 +16,6 @@ const CANCEL: &str = include_str!("../../tests/fixtures/acp-v2/cancel.jsonl");
 const RESUME: &str = include_str!("../../tests/fixtures/acp-v2/resume.jsonl");
 const INITIALIZE_V1: &str = include_str!("../../tests/fixtures/acp-v2/initialize-v1.jsonl");

-#[test]
-fn auth_required_matches_authentication_words_and_sign_in_phrases() {
-    for (code, message, expected) in [
-        (AUTH_REQUIRED, "This account is not eligible.", true),
-        (codes::INTERNAL_ERROR, "Auth required", true),
-        (codes::INTERNAL_ERROR, "Authentication failed", true),
-        (codes::INTERNAL_ERROR, "Failed to authenticate. API Error: 401", true),
-        (codes::INTERNAL_ERROR, "Failed to authenticate. API Error: 403", true),
-        (codes::INTERNAL_ERROR, "Not authenticated", true),
-        (codes::INTERNAL_ERROR, "Authorization failed", true),
-        (codes::INTERNAL_ERROR, "Authorize your account", true),
-        (codes::INTERNAL_ERROR, "Unauthenticated", true),
-        (codes::INTERNAL_ERROR, "Unauthentication error", true),
-        (codes::INTERNAL_ERROR, "Unauthorized", true),
-        (codes::INTERNAL_ERROR, "Unauthorization error", true),
-        (codes::INTERNAL_ERROR, "OAuth token has expired", true),
-        (codes::INTERNAL_ERROR, "OAuth2 token has expired", true),
-        (codes::INTERNAL_ERROR, "You are not logged in", true),
-        (codes::INTERNAL_ERROR, "You are logged out", true),
-        (codes::INTERNAL_ERROR, "Please sign in", true),
-        (codes::INTERNAL_ERROR, "Please log in", true),
-        (codes::INTERNAL_ERROR, "Login required", true),
-        (codes::INTERNAL_ERROR, "author", false),
-        (codes::INTERNAL_ERROR, "authors", false),
-        (codes::INTERNAL_ERROR, "authority", false),
-        (codes::INTERNAL_ERROR, "authored", false),
-        (codes::INTERNAL_ERROR, "reauthenticate", false),
-        (codes::INTERNAL_ERROR, "preauthorized", false),
-        (codes::INTERNAL_ERROR, "signal input failed", false),
-        (codes::INTERNAL_ERROR, "catalog index failed", false),
-        (codes::INTERNAL_ERROR, "login succeeded", false),
-    ] {
-        assert_eq!(auth_required(code, message), expected, "code={code}, message={message:?}");
-    }
-}
-
 /// The messages of a fixture going `dir` (`in` or `out`).
 pub(crate) fn frames(fixture: &str, dir: &str) -> Vec<Value> {
    fixture
@@ -135,36 +99,6 @@ fn the_shape_decides_the_version_not_the_number() {
    assert_eq!((n.generation, n.load_session(), n.session("fork")), (2, false, false));
 }

-#[test]
-fn picks_non_terminal_agent_auth_method() {
-    let v1 = Negotiated::from_initialize(&json!({
-        "protocolVersion": 1,
-        "authMethods": [
-            { "id": "cli_login", "_meta": { "terminal-auth": { "command": "copilot", "args": ["login"] } } },
-            { "id": "terminal_login", "type": "terminal", "args": ["login"] },
-            { "id": "api_key", "type": "env_var" },
-            { "id": "github_oauth", "name": "GitHub OAuth" }
-        ]
-    }));
-    assert_eq!(v1.agent_auth_method(), Some("github_oauth"));
-
-    let v2 = Negotiated::from_initialize(&json!({
-        "protocolVersion": 2,
-        "info": { "name": "x", "version": "1" },
-        "authMethods": [
-            { "type": "terminal", "methodId": "cli", "name": "CLI", "args": ["login"] },
-            { "type": "agent", "methodId": "oauth", "name": "OAuth" }
-        ]
-    }));
-    assert_eq!(v2.agent_auth_method(), Some("oauth"));
-
-    let terminal_only = Negotiated::from_initialize(&json!({
-        "protocolVersion": 1,
-        "authMethods": [{ "id": "cli", "type": "terminal", "args": ["login"] }]
-    }));
-    assert_eq!(terminal_only.agent_auth_method(), None);
-}
-
 #[test]
 fn meta_and_auth_methods_pass_through() {
    // The native shims advertise their extensions in `agentCapabilities._meta`.
@@ -593,13 +527,3 @@ async fn v1_requests_are_sent_in_v2() {
        .collect();
    assert_eq!(commands, [&json!("28846a4c-c3e8-4a45-a3d0-c19f10d19d1a"), &json!("s1")]);
 }
-
-#[test]
-fn stdio_mcp_is_v1_baseline_and_negotiated_in_v2() {
-    assert!(super::Negotiated::from_initialize(&json!({"protocolVersion":1,"agentCapabilities":{}})).mcp_stdio());
-    assert!(!super::Negotiated::from_initialize(&json!({"info":{},"capabilities":{"session":{}}})).mcp_stdio());
-    assert!(
-        super::Negotiated::from_initialize(&json!({"info":{},"capabilities":{"session":{"mcp":{"stdio":{}}}}}))
-            .mcp_stdio()
-    );
-}
@@ -2,8 +2,7 @@
 //! the agent reports them over ACP.

 use crate::model::{
-    AgentCommand, AgentCommandSource, AgentConfigOption, AgentConfigValue, AgentConfigVia, AgentCost, AgentLimit,
-    AgentUsage,
+    AgentCommand, AgentConfigOption, AgentConfigValue, AgentConfigVia, AgentCost, AgentLimit, AgentUsage,
 };
 use serde_json::{Value, json};

@@ -36,32 +35,20 @@ pub(crate) fn add_client_options(provider: &str, config: &mut Vec<AgentConfigOpt
    });
 }

-/// Whether the current settings approve tool requests without asking: a bypass mode,
-/// an allow-all permissions option, or a bypass approval policy.
-pub(crate) fn bypass_approvals(config: &[AgentConfigOption]) -> bool {
-    let selected = |category: &str| {
-        config.iter().find(|o| o.category.as_deref() == Some(category)).and_then(|o| o.current.as_deref())
-    };
-    selected("mode").is_some_and(is_bypass_mode)
-        || selected("permissions").is_some_and(|v| matches!(v.to_ascii_lowercase().as_str(), "on" | "true"))
-        || selected("approval").is_some_and(|v| v.eq_ignore_ascii_case("bypass"))
+pub(crate) fn bypass_approvals(provider: &str, config: &[AgentConfigOption]) -> bool {
+    provider == "cursor" && config.iter().any(|o| o.id == CURSOR_APPROVAL && o.current.as_deref() == Some("bypass"))
 }

 /// The mode that approves everything without asking (`bypassPermissions`, `yolo`, `full-access`…), if the agent has one.
 pub(crate) fn bypass_mode(options: &[AgentConfigOption]) -> Option<(&AgentConfigOption, &AgentConfigValue)> {
    let option = options.iter().find(|o| o.category.as_deref() == Some("mode"))?;
-    let value = option.values.iter().find(|v| is_bypass_mode(&v.value))?;
+    let value = option.values.iter().find(|v| {
+        let m: String = v.value.to_lowercase().chars().filter(char::is_ascii_lowercase).collect();
+        m.contains("bypass") || m == "yolo" || m.contains("fullaccess") || m == "dangerous"
+    })?;
    Some((option, value))
 }

-fn is_bypass_mode(mode: &str) -> bool {
-    // Mode ids can be URL-like (`…/session-modes#yolo`), as the composer's mode icon also assumes.
-    let lower = mode.to_lowercase();
-    let m: String =
-        lower.rsplit(['#', '/']).next().unwrap_or_default().chars().filter(char::is_ascii_lowercase).collect();
-    m.contains("bypass") || m == "yolo" || m.contains("fullaccess") || m == "dangerous"
-}
-
 /// The settings in a `session/new` or `session/load` result: its select `configOptions`,
 /// plus the older `modes` / `models` fields for what those don't cover.
 pub(crate) fn options_of(result: &Value) -> Vec<AgentConfigOption> {
@@ -146,22 +133,15 @@ pub(crate) fn set_request(option: &AgentConfigOption, value: &str) -> (&'static
 }

 /// `available_commands_update`.
-pub(crate) fn commands_of(update: &Value, provider: &str) -> Vec<AgentCommand> {
+pub(crate) fn commands_of(update: &Value) -> Vec<AgentCommand> {
    update
        .get("availableCommands")
        .and_then(Value::as_array)
        .into_iter()
        .flatten()
        .filter_map(|c| {
-            let name = c.get("name")?.as_str()?.trim_start_matches('/');
-            let source = if provider == "codex-acp" && name.starts_with('$') {
-                AgentCommandSource::Skill
-            } else {
-                c.get("source").and_then(|s| serde_json::from_value(s.clone()).ok()).unwrap_or_default()
-            };
            Some(AgentCommand {
-                name: name.to_owned(),
-                source,
+                name: c.get("name")?.as_str()?.trim_start_matches('/').to_owned(),
                description: str_of(c, "description").unwrap_or_default(),
                hint: c.pointer("/input/hint").and_then(Value::as_str).filter(|h| !h.is_empty()).map(str::to_owned),
            })
@@ -287,85 +267,12 @@ mod tests {
        assert_eq!(ids(&c), [("model", Some("b")), ("mode", Some("code"))]);
    }

-    #[test]
-    fn selected_bypass_settings_approve_without_asking() {
-        let full_access = options_of(&json!({
-            "modes": {"currentModeId": "full-access", "availableModes": [
-                {"id": "ask", "name": "Ask"}, {"id": "full-access", "name": "Full Access"}
-            ]}
-        }));
-        assert!(bypass_approvals(&full_access));
-        assert_eq!(bypass_mode(&full_access).map(|(_, v)| v.value.as_str()), Some("full-access"));
-
-        let asking = options_of(&json!({
-            "modes": {"currentModeId": "ask", "availableModes": [
-                {"id": "ask", "name": "Ask"}, {"id": "full-access", "name": "Full Access"}
-            ]}
-        }));
-        assert!(!bypass_approvals(&asking));
-        assert_eq!(
-            bypass_mode(&asking).map(|(_, v)| v.value.as_str()),
-            Some("full-access"),
-            "the offered bypass mode stays available"
-        );
-
-        let permissions = |current: &str| {
-            options_of(&json!({"configOptions": [{
-                "id": "allow_all", "name": "Allow All", "category": "permissions", "type": "select",
-                "currentValue": current, "options": [{"value": "off"}, {"value": "on"}]
-            }]}))
-        };
-        assert!(bypass_approvals(&permissions("on")));
-        assert!(bypass_approvals(&permissions("TRUE")));
-        assert!(!bypass_approvals(&permissions("off")));
-
-        let approval = options_of(&json!({"configOptions": [{
-            "id": "approval", "name": "Approvals", "category": "approval", "type": "select",
-            "currentValue": "bypass", "options": [{"value": "ask"}, {"value": "bypass"}]
-        }]}));
-        assert!(bypass_approvals(&approval));
-
-        // The composer's mode icon splits URL-like ids on `#` / `/`; the backend must agree.
-        let url_mode = options_of(&json!({
-            "modes": {"currentModeId": "https://agentclientprotocol.com/protocol/session-modes#yolo",
-                      "availableModes": [{"id": "https://agentclientprotocol.com/protocol/session-modes#yolo"}]}
-        }));
-        assert!(bypass_approvals(&url_mode));
-    }
-
-    #[test]
-    fn command_sources_in_updates_and_stored_tasks() {
-        let update = json!({"availableCommands": [
-            {"name": "review", "source": "skill"},
-            {"name": "$lint"},
-            {"name": "compact"}
-        ]});
-        let sources = |provider| commands_of(&update, provider).into_iter().map(|c| c.source).collect::<Vec<_>>();
-        assert_eq!(
-            sources("codex-acp"),
-            [AgentCommandSource::Skill, AgentCommandSource::Skill, AgentCommandSource::Command]
-        );
-        assert_eq!(
-            sources("custom"),
-            [AgentCommandSource::Skill, AgentCommandSource::Command, AgentCommandSource::Command]
-        );
-        let old: AgentCommand =
-            serde_json::from_value(json!({"name": "review", "description": "Review", "hint": null})).unwrap();
-        assert_eq!(old.source, AgentCommandSource::Command);
-        let skill = AgentCommand { source: AgentCommandSource::Skill, ..old };
-        assert_eq!(serde_json::from_value::<AgentCommand>(serde_json::to_value(&skill).unwrap()).unwrap(), skill);
-    }
-
    #[test]
    fn commands_and_usage() {
-        let cmds = commands_of(
-            &json!({"availableCommands": [
-                {"name": "review", "description": "Review changes", "input": {"hint": "what to review"}},
-                {"name": "/init", "description": "Write CLAUDE.md", "input": null}
-            ]}),
-            "claude",
-        );
-        assert_eq!(cmds[0].source, AgentCommandSource::Command);
+        let cmds = commands_of(&json!({"availableCommands": [
+            {"name": "review", "description": "Review changes", "input": {"hint": "what to review"}},
+            {"name": "/init", "description": "Write CLAUDE.md", "input": null}
+        ]}));
        assert_eq!(cmds[0].hint.as_deref(), Some("what to review"));
        assert_eq!((cmds[1].name.as_str(), cmds[1].hint.as_ref()), ("init", None));
        let u = usage_of(&json!({"used": 1200, "size": 200000, "cost": {"amount": 0.42, "currency": "USD"}})).unwrap();
@@ -1,325 +0,0 @@
-//! Sessions the user started outside OpenIDEA (a terminal, another editor, the CLI):
-//! scanned so they can be listed and imported as tasks instead of re-explained (#312).
-//!
-//! Only the native providers keep transcripts on disk in a readable form: Claude Code
-//! (`<config>/projects/*/<id>.jsonl`, see `native::claude::history`) and Codex
-//! (`<home>/.codex/sessions/**`, rollout files with a `session_meta` line).
-
-use super::native::claude::history;
-use serde::Serialize;
-use specta::Type;
-use std::io::BufRead;
-use std::path::{Path, PathBuf};
-
-/// A session on this machine that no task holds yet.
-#[derive(Clone, Debug, Serialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub struct ExternalSession {
-    /// The [`crate::AgentProvider`] id that owns it (`claude`, `codex`).
-    pub provider: String,
-    /// The id resuming it names (`--resume`, `thread/resume`).
-    pub session_id: String,
-    pub title: String,
-    /// Where it ran, when the transcript names one.
-    pub cwd: Option<String>,
-    /// File modification time, ms since the epoch.
-    pub updated_ms: f64,
-}
-
-/// Modification time of `path` in ms, else 0.
-fn mtime(path: &Path) -> f64 {
-    path.metadata()
-        .and_then(|m| m.modified())
-        .ok()
-        .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
-        .map(|d| d.as_millis() as f64)
-        .unwrap_or(0.0)
-}
-
-/// Short display text: collapsed whitespace, truncated to `MAX_TITLE` chars.
-fn short(text: &str) -> String {
-    const MAX_TITLE: usize = 80;
-    let flat: String = text.split_whitespace().collect::<Vec<_>>().join(" ");
-    if flat.chars().count() <= MAX_TITLE {
-        flat
-    } else {
-        format!("{}…", flat.chars().take(MAX_TITLE - 1).collect::<String>())
-    }
-}
-
-/// The text of a Claude Code transcript entry's message, when it carries prose.
-fn message_text(e: &serde_json::Value) -> Option<String> {
-    match e.pointer("/message/content") {
-        Some(serde_json::Value::String(s)) => Some(s.clone()),
-        Some(serde_json::Value::Array(blocks)) => {
-            let text: Vec<&str> = blocks
-                .iter()
-                .filter(|b| b.get("type").and_then(serde_json::Value::as_str) == Some("text"))
-                .filter_map(|b| b.get("text").and_then(serde_json::Value::as_str))
-                .collect();
-            (!text.is_empty()).then(|| text.join("\n"))
-        }
-        _ => None,
-    }
-}
-
-/// Whether a session that ran in `cwd` belongs to the project at `root` (in it or below it).
-fn in_project(cwd: Option<&str>, root: &Path) -> bool {
-    cwd.is_some_and(|cwd| Path::new(cwd).starts_with(root))
-}
-
-/// Claude Code transcripts of the project at `root`: `<config>/projects/<escaped cwd>/<id>.jsonl`.
-/// Only the folders named after `root` or a folder below it are read, so other projects'
-/// transcripts (often gigabytes) are never opened.
-pub fn claude_sessions(config_dir: &Path, root: &Path) -> Vec<ExternalSession> {
-    let mut out = Vec::new();
-    let projects = config_dir.join("projects");
-    let escaped = history::escape(root);
-    let dirs: Vec<PathBuf> = std::fs::read_dir(&projects)
-        .into_iter()
-        .flatten()
-        .flatten()
-        .filter(|d| {
-            let name = d.file_name().to_string_lossy().into_owned();
-            name == escaped || name.starts_with(&format!("{escaped}-"))
-        })
-        .map(|d| d.path())
-        .collect();
-    for dir in dirs {
-        let files: Vec<PathBuf> = std::fs::read_dir(&dir)
-            .into_iter()
-            .flatten()
-            .flatten()
-            .map(|d| d.path())
-            .filter(|p| p.extension().is_some_and(|e| e == "jsonl"))
-            .collect();
-        for path in files {
-            let id = path.file_stem().and_then(|s| s.to_str()).unwrap_or_default().to_owned();
-            if id.is_empty() {
-                continue;
-            }
-            let entries = history::read(&path).unwrap_or_default();
-            if entries.is_empty() {
-                continue;
-            }
-            let title = history::title(&entries)
-                .or_else(|| entries.iter().filter(|e| history::is_turn_start(e)).filter_map(message_text).next())
-                .map(|t| short(&t))
-                .unwrap_or_else(|| format!("Claude Code session {}", &id[..id.len().min(8)]));
-            let cwd = entries
-                .iter()
-                .filter_map(|e| e.get("cwd").and_then(serde_json::Value::as_str))
-                .next()
-                .map(str::to_owned);
-            // Escaping is lossy (`a/b-c` and `a/b/c` share a folder): the transcript decides.
-            if !in_project(cwd.as_deref(), root) {
-                continue;
-            }
-            out.push(ExternalSession {
-                provider: "claude".to_owned(),
-                session_id: id,
-                title,
-                cwd,
-                updated_ms: mtime(&path),
-            });
-        }
-    }
-    out
-}
-
-/// The `session_meta` line of a Codex rollout file: `(id, cwd)`, across shapes.
-fn codex_meta(line: &serde_json::Value) -> Option<(String, Option<String>)> {
-    let payload =
-        line.get("payload").filter(|p| p.get("type").and_then(serde_json::Value::as_str) == Some("session_meta"));
-    let inner = payload.and_then(|p| p.get("payload")).or_else(|| {
-        line.get("type").and_then(serde_json::Value::as_str).filter(|t| *t == "session_meta").and(Some(line))
-    })?;
-    let id = inner.get("id").and_then(serde_json::Value::as_str)?.to_owned();
-    let cwd = inner.get("cwd").and_then(serde_json::Value::as_str).map(str::to_owned);
-    Some((id, cwd))
-}
-
-/// A prose line of a Codex rollout file (a user message), across shapes.
-fn codex_user_text(line: &serde_json::Value) -> Option<String> {
-    let payload = line.get("payload")?;
-    let ty = payload.get("type").and_then(serde_json::Value::as_str)?;
-    if !(ty == "user_message" || ty == "userMessage" || ty == "event_msg") {
-        return None;
-    }
-    let inner = payload.get("payload").unwrap_or(&serde_json::Value::Null);
-    for v in [payload, inner] {
-        if let Some(s) = v.get("message").and_then(serde_json::Value::as_str) {
-            return Some(s.to_owned());
-        }
-        if let Some(s) = v.get("text").and_then(serde_json::Value::as_str) {
-            return Some(s.to_owned());
-        }
-    }
-    None
-}
-
-/// One rollout file's session, or `None` when it names no `session_meta`.
-fn codex_file(path: &Path) -> Option<ExternalSession> {
-    let file = std::fs::File::open(path).ok()?;
-    let mut id: Option<(String, Option<String>)> = None;
-    let mut title: Option<String> = None;
-    // `session_meta` is first, but cap the scan: giant rollouts must not stall listing.
-    for line in std::io::BufReader::new(file).lines().take(400) {
-        let Ok(line) = line else { break };
-        let Ok(v) = serde_json::from_str::<serde_json::Value>(&line) else { continue };
-        if id.is_none()
-            && let Some(meta) = codex_meta(&v)
-        {
-            id = Some(meta);
-        }
-        if title.is_none()
-            && let Some(t) = codex_user_text(&v)
-        {
-            title = Some(short(&t));
-        }
-        if id.is_some() && title.is_some() {
-            break;
-        }
-    }
-    let (session_id, cwd) = id?;
-    Some(ExternalSession {
-        provider: "codex".to_owned(),
-        title: title.unwrap_or_else(|| format!("Codex session {}", &session_id[..session_id.len().min(8)])),
-        session_id,
-        cwd,
-        updated_ms: mtime(path),
-    })
-}
-
-/// Collects `*.jsonl` below `dir`, up to 4 levels (`sessions/YYYY/MM/DD/<rollout>`).
-fn rollout_files(dir: &Path, depth: usize, out: &mut Vec<PathBuf>) {
-    if depth == 0 {
-        return;
-    }
-    for entry in std::fs::read_dir(dir).into_iter().flatten().flatten() {
-        let path = entry.path();
-        if path.is_dir() {
-            rollout_files(&path, depth - 1, out);
-        } else if path.extension().is_some_and(|e| e == "jsonl") {
-            out.push(path);
-        }
-    }
-}
-
-/// Codex sessions of the project at `root`: `<home>/.codex/sessions/**`.
-pub fn codex_sessions(codex_home: &Path, root: &Path) -> Vec<ExternalSession> {
-    let mut files = Vec::new();
-    rollout_files(&codex_home.join("sessions"), 4, &mut files);
-    files.iter().filter_map(|p| codex_file(p)).filter(|s| in_project(s.cwd.as_deref(), root)).collect()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use serde_json::json;
-    use std::io::Write;
-
-    fn write(path: &Path, lines: &[serde_json::Value]) {
-        std::fs::create_dir_all(path.parent().unwrap()).unwrap();
-        let mut f = std::fs::File::create(path).unwrap();
-        for line in lines {
-            writeln!(f, "{line}").unwrap();
-        }
-    }
-
-    fn claude_user(uuid: &str, text: &str) -> serde_json::Value {
-        json!({"type": "user", "uuid": uuid, "parentUuid": null,
-            "message": {"role": "user", "content": text}, "cwd": "/work/app"})
-    }
-
-    #[test]
-    fn lists_claude_transcripts_with_titles() {
-        let tmp = tempfile::tempdir().unwrap();
-        write(
-            &tmp.path().join("projects/-work-app/abc123.jsonl"),
-            &[
-                claude_user("u1", "fix the login bug"),
-                json!({"type": "assistant", "uuid": "a1", "parentUuid": "u1",
-                    "message": {"role": "assistant", "content": []}}),
-                json!({"type": "ai-title", "aiTitle": "Login fix"}),
-            ],
-        );
-        write(&tmp.path().join("projects/-work-app/empty.jsonl"), &[]);
-        let sessions = claude_sessions(tmp.path(), Path::new("/work/app"));
-        assert_eq!(sessions.len(), 1);
-        let s = &sessions[0];
-        assert_eq!((s.provider.as_str(), s.session_id.as_str()), ("claude", "abc123"));
-        assert_eq!(s.title, "Login fix");
-        assert_eq!(s.cwd.as_deref(), Some("/work/app"));
-        assert!(s.updated_ms > 0.0);
-    }
-
-    #[test]
-    fn claude_title_falls_back_to_the_first_prompt() {
-        let tmp = tempfile::tempdir().unwrap();
-        write(&tmp.path().join("projects/-work-app/def456.jsonl"), &[claude_user("u1", "hello there")]);
-        let sessions = claude_sessions(tmp.path(), Path::new("/work/app"));
-        assert_eq!(sessions.len(), 1);
-        assert_eq!(sessions[0].title, "hello there");
-    }
-
-    #[test]
-    fn lists_codex_rollouts_with_meta() {
-        let tmp = tempfile::tempdir().unwrap();
-        write(
-            &tmp.path().join("sessions/2026/01/02/rollout-01.jsonl"),
-            &[
-                json!({"timestamp": "t", "payload": {"type": "session_meta",
-                    "payload": {"id": "thread-1", "cwd": "/work/app"}}}),
-                json!({"timestamp": "t", "payload": {"type": "user_message",
-                    "payload": {"message": "add tests"}}}),
-            ],
-        );
-        write(&tmp.path().join("sessions/notes.jsonl"), &[json!({"nope": true})]);
-        let sessions = codex_sessions(tmp.path(), Path::new("/work"));
-        assert_eq!(sessions.len(), 1);
-        let s = &sessions[0];
-        assert_eq!((s.provider.as_str(), s.session_id.as_str()), ("codex", "thread-1"));
-        assert_eq!(s.title, "add tests");
-        assert_eq!(s.cwd.as_deref(), Some("/work/app"));
-    }
-
-    #[test]
-    fn missing_directories_list_nothing() {
-        let tmp = tempfile::tempdir().unwrap();
-        assert!(claude_sessions(&tmp.path().join("nope"), Path::new("/work")).is_empty());
-        assert!(codex_sessions(&tmp.path().join("nope"), Path::new("/work")).is_empty());
-    }
-
-    #[test]
-    fn only_sessions_of_the_project_are_listed() {
-        let tmp = tempfile::tempdir().unwrap();
-        let user = |cwd: &str| {
-            json!({"type": "user", "uuid": "u1", "parentUuid": null,
-                "message": {"role": "user", "content": "hi"}, "cwd": cwd})
-        };
-        write(&tmp.path().join("projects/-work-app/in-root.jsonl"), &[user("/work/app")]);
-        write(&tmp.path().join("projects/-work-app-web/below.jsonl"), &[user("/work/app/web")]);
-        // `/work/app-old` escapes like a folder below `/work/app`; its transcript says otherwise.
-        write(&tmp.path().join("projects/-work-app-old/sibling.jsonl"), &[user("/work/app-old")]);
-        write(&tmp.path().join("projects/-other/elsewhere.jsonl"), &[user("/other")]);
-        let mut ids: Vec<String> =
-            claude_sessions(tmp.path(), Path::new("/work/app")).into_iter().map(|s| s.session_id).collect();
-        ids.sort();
-        assert_eq!(ids, ["below", "in-root"]);
-
-        let rollout = |name: &str, cwd: &str| {
-            write(
-                &tmp.path().join(format!("codex/sessions/2026/01/02/{name}.jsonl")),
-                &[json!({"payload": {"type": "session_meta", "payload": {"id": name, "cwd": cwd}}})],
-            )
-        };
-        rollout("mine", "/work/app/api");
-        rollout("theirs", "/other");
-        let codex: Vec<String> = codex_sessions(&tmp.path().join("codex"), Path::new("/work/app"))
-            .into_iter()
-            .map(|s| s.session_id)
-            .collect();
-        assert_eq!(codex, ["mine"]);
-    }
-}
@@ -1,507 +0,0 @@
-//! Model Context Protocol (MCP) server configurations stored in OpenIDEA's own settings
-//! (global `settings.toml` and project `.openidea/settings.toml`), passed to ACP agents in
-//! `session/new`, `session/load`, and `session/fork`, plus one-way import from `.mcp.json` /
-//! `.vscode/mcp.json`.
-
-use crate::acp::Negotiated;
-use crate::{AgentMcpServer, McpKeyValue, McpScope, McpServer, McpServerInput, McpTransport};
-use serde_json::{Value, json};
-use std::collections::{BTreeMap, HashSet};
-use std::path::Path;
-
-/// Stable ID for a server in a given scope (`"user::<name>"` or `"workspace::<name>"`).
-pub fn server_id(scope: McpScope, name: &str) -> String {
-    let prefix = match scope {
-        McpScope::User => "user",
-        McpScope::Workspace => "workspace",
-    };
-    format!("{prefix}::{name}")
-}
-
-/// Parses a server ID (`"user::<name>"` or `"workspace::<name>"`).
-pub fn parse_server_id(id: &str) -> Option<(McpScope, &str)> {
-    let (prefix, name) = id.split_once("::")?;
-    if name.is_empty() {
-        return None;
-    }
-    match prefix {
-        "user" => Some((McpScope::User, name)),
-        "workspace" => Some((McpScope::Workspace, name)),
-        _ => None,
-    }
-}
-
-/// Converts the User (`settings.toml`) and Workspace (`.openidea/settings.toml`) MCP server maps
-/// into the ordered list displayed in Settings › Agents › MCP Servers.
-pub fn servers_from_settings(
-    user: &BTreeMap<String, AgentMcpServer>,
-    workspace: &BTreeMap<String, AgentMcpServer>,
-) -> Vec<McpServer> {
-    user.iter()
-        .map(|(name, cfg)| to_mcp_server(McpScope::User, name, cfg))
-        .chain(workspace.iter().map(|(name, cfg)| to_mcp_server(McpScope::Workspace, name, cfg)))
-        .collect()
-}
-
-fn to_mcp_server(scope: McpScope, name: &str, cfg: &AgentMcpServer) -> McpServer {
-    McpServer {
-        id: server_id(scope, name),
-        name: name.to_owned(),
-        scope,
-        transport: cfg.transport,
-        enabled: cfg.enabled,
-        command: cfg.command.clone(),
-        args: cfg.args.clone(),
-        env: cfg.env.iter().map(|(k, v)| McpKeyValue { name: k.clone(), value: v.clone() }).collect(),
-        url: cfg.url.clone(),
-        headers: cfg.headers.iter().map(|(k, v)| McpKeyValue { name: k.clone(), value: v.clone() }).collect(),
-        agents: cfg.agents.clone(),
-    }
-}
-
-fn normalize_provider(id: &str) -> &str {
-    id.strip_suffix("-acp").unwrap_or(id)
-}
-
-fn matches_agent(agents: &[String], provider: &str) -> bool {
-    if agents.is_empty() {
-        return true;
-    }
-    let target = normalize_provider(provider);
-    agents.iter().any(|a| {
-        let trimmed = a.trim();
-        trimmed == provider || normalize_provider(trimmed) == target
-    })
-}
-
-/// Builds the ACP `mcpServers` array for `session/new`, `session/load`, and `session/fork`.
-/// Workspace entries take precedence over User entries with the same name.
-pub(crate) fn acp_mcp_servers(all: &[McpServer], provider: &str, init: &Negotiated) -> Vec<Value> {
-    let supports_stdio = init.mcp_stdio();
-    let supports_http = init.mcp("http");
-    let supports_sse = init.mcp("sse");
-    let mut seen = HashSet::new();
-    let mut servers = Vec::new();
-
-    let ordered =
-        all.iter().filter(|s| s.scope == McpScope::Workspace).chain(all.iter().filter(|s| s.scope == McpScope::User));
-
-    for srv in ordered {
-        if !srv.enabled || !matches_agent(&srv.agents, provider) || !seen.insert(srv.name.clone()) {
-            continue;
-        }
-        match srv.transport {
-            McpTransport::Stdio if supports_stdio => {
-                let Some(cmd) = srv.command.as_deref().filter(|c| !c.trim().is_empty()) else {
-                    continue;
-                };
-                let env: Vec<Value> = srv.env.iter().map(|kv| json!({ "name": kv.name, "value": kv.value })).collect();
-                servers.push(json!({
-                    "name": srv.name,
-                    "command": cmd,
-                    "args": srv.args,
-                    "env": env,
-                }));
-            }
-            McpTransport::Http if supports_http => {
-                let Some(url) = srv.url.as_deref().filter(|u| !u.trim().is_empty()) else {
-                    continue;
-                };
-                let headers: Vec<Value> =
-                    srv.headers.iter().map(|kv| json!({ "name": kv.name, "value": kv.value })).collect();
-                servers.push(json!({
-                    "type": "http",
-                    "name": srv.name,
-                    "url": url,
-                    "headers": headers,
-                }));
-            }
-            McpTransport::Sse if supports_sse => {
-                let Some(url) = srv.url.as_deref().filter(|u| !u.trim().is_empty()) else {
-                    continue;
-                };
-                let headers: Vec<Value> =
-                    srv.headers.iter().map(|kv| json!({ "name": kv.name, "value": kv.value })).collect();
-                servers.push(json!({
-                    "type": "sse",
-                    "name": srv.name,
-                    "url": url,
-                    "headers": headers,
-                }));
-            }
-            _ => {}
-        }
-    }
-
-    servers
-}
-
-/// Applies a create or update operation to the User / Workspace MCP server maps.
-pub fn apply_save(
-    user: &mut BTreeMap<String, AgentMcpServer>,
-    workspace: &mut BTreeMap<String, AgentMcpServer>,
-    has_workspace: bool,
-    input: McpServerInput,
-) -> Result<(), String> {
-    let name = input.name.trim();
-    if name.is_empty() {
-        return Err("Server name is required".into());
-    }
-    if input.scope == McpScope::Workspace && !has_workspace {
-        return Err("Open a project to configure workspace MCP servers".into());
-    }
-    let cfg = match input.transport {
-        McpTransport::Stdio => {
-            let cmd = input.command.as_deref().map(str::trim).unwrap_or_default();
-            if cmd.is_empty() {
-                return Err("Command is required for stdio MCP servers".into());
-            }
-            let env = input
-                .env
-                .into_iter()
-                .filter_map(|kv| {
-                    let k = kv.name.trim();
-                    (!k.is_empty()).then(|| (k.to_owned(), kv.value))
-                })
-                .collect();
-            AgentMcpServer {
-                transport: McpTransport::Stdio,
-                enabled: input.enabled,
-                command: Some(cmd.to_owned()),
-                args: input.args,
-                env,
-                url: None,
-                headers: BTreeMap::new(),
-                agents: normalize_agents_list(input.agents),
-            }
-        }
-        McpTransport::Http | McpTransport::Sse => {
-            let url = input.url.as_deref().map(str::trim).unwrap_or_default();
-            if url.is_empty() {
-                return Err("URL is required for HTTP/SSE MCP servers".into());
-            }
-            let headers = input
-                .headers
-                .into_iter()
-                .filter_map(|kv| {
-                    let k = kv.name.trim();
-                    (!k.is_empty()).then(|| (k.to_owned(), kv.value))
-                })
-                .collect();
-            AgentMcpServer {
-                transport: input.transport,
-                enabled: input.enabled,
-                command: None,
-                args: Vec::new(),
-                env: BTreeMap::new(),
-                url: Some(url.to_owned()),
-                headers,
-                agents: normalize_agents_list(input.agents),
-            }
-        }
-    };
-
-    if let Some(prev_id) = input.id.as_deref()
-        && let Some((prev_scope, prev_name)) = parse_server_id(prev_id)
-        && (prev_scope != input.scope || prev_name != name)
-    {
-        match prev_scope {
-            McpScope::User => {
-                user.remove(prev_name);
-            }
-            McpScope::Workspace => {
-                workspace.remove(prev_name);
-            }
-        }
-    }
-
-    match input.scope {
-        McpScope::User => {
-            user.insert(name.to_owned(), cfg);
-        }
-        McpScope::Workspace => {
-            workspace.insert(name.to_owned(), cfg);
-        }
-    }
-    Ok(())
-}
-
-/// Enables or disables a User or Workspace MCP server by ID.
-pub fn apply_set_enabled(
-    user: &mut BTreeMap<String, AgentMcpServer>,
-    workspace: &mut BTreeMap<String, AgentMcpServer>,
-    id: &str,
-    enabled: bool,
-) -> Result<McpScope, String> {
-    let (scope, name) = parse_server_id(id).ok_or_else(|| format!("MCP server `{id}` not found"))?;
-    let map = match scope {
-        McpScope::User => user,
-        McpScope::Workspace => workspace,
-    };
-    let srv = map.get_mut(name).ok_or_else(|| format!("MCP server `{name}` not found"))?;
-    srv.enabled = enabled;
-    Ok(scope)
-}
-
-/// Removes a User or Workspace MCP server by ID.
-pub fn apply_remove(
-    user: &mut BTreeMap<String, AgentMcpServer>,
-    workspace: &mut BTreeMap<String, AgentMcpServer>,
-    id: &str,
-) -> Result<McpScope, String> {
-    let (scope, name) = parse_server_id(id).ok_or_else(|| format!("MCP server `{id}` not found"))?;
-    let map = match scope {
-        McpScope::User => user,
-        McpScope::Workspace => workspace,
-    };
-    if map.remove(name).is_none() {
-        return Err(format!("MCP server `{name}` not found"));
-    }
-    Ok(scope)
-}
-
-/// Imports MCP servers from `<workspace_root>/.mcp.json` and `<workspace_root>/.vscode/mcp.json`
-/// into `workspace` without modifying the external files. Returns the number of newly added servers.
-pub fn apply_import(workspace: &mut BTreeMap<String, AgentMcpServer>, workspace_root: &Path) -> usize {
-    let mut added = 0;
-    for rel in [".mcp.json", ".vscode/mcp.json"] {
-        let path = workspace_root.join(rel);
-        for (name, srv) in read_external_file(&path) {
-            if let std::collections::btree_map::Entry::Vacant(e) = workspace.entry(name) {
-                e.insert(srv);
-                added += 1;
-            }
-        }
-    }
-    added
-}
-
-fn normalize_agents_list(agents: Vec<String>) -> Vec<String> {
-    let mut out = Vec::new();
-    for a in agents {
-        let trimmed = a.trim();
-        if !trimmed.is_empty() && !out.iter().any(|existing: &String| existing == trimmed) {
-            out.push(trimmed.to_owned());
-        }
-    }
-    out
-}
-
-fn read_external_file(path: &Path) -> BTreeMap<String, AgentMcpServer> {
-    let Ok(bytes) = std::fs::read(path) else {
-        return BTreeMap::new();
-    };
-    let Ok(root) = serde_json::from_slice::<Value>(&bytes) else {
-        return BTreeMap::new();
-    };
-    let Some(servers_obj) = root.get("mcpServers").or_else(|| root.get("servers")).and_then(Value::as_object) else {
-        return BTreeMap::new();
-    };
-
-    let mut out = BTreeMap::new();
-    for (name, def) in servers_obj {
-        let name = name.trim();
-        let Some(obj) = def.as_object().filter(|_| !name.is_empty()) else {
-            continue;
-        };
-        let disabled = obj.get("disabled").and_then(Value::as_bool).unwrap_or(false)
-            || obj.get("enabled").and_then(Value::as_bool) == Some(false);
-        let type_str = obj.get("type").and_then(Value::as_str).unwrap_or_default().to_ascii_lowercase();
-        let url = obj
-            .get("url")
-            .or_else(|| obj.get("serverUrl"))
-            .and_then(Value::as_str)
-            .map(str::trim)
-            .filter(|s| !s.is_empty())
-            .map(str::to_owned);
-        let command =
-            obj.get("command").and_then(Value::as_str).map(str::trim).filter(|s| !s.is_empty()).map(str::to_owned);
-
-        let transport = match type_str.as_str() {
-            "sse" => McpTransport::Sse,
-            "http" | "streamable-http" | "streamable_http" => McpTransport::Http,
-            "stdio" | "local" => McpTransport::Stdio,
-            _ if url.is_some() && command.is_none() => McpTransport::Http,
-            _ => McpTransport::Stdio,
-        };
-
-        match transport {
-            McpTransport::Stdio if command.is_none() => continue,
-            McpTransport::Http | McpTransport::Sse if url.is_none() => continue,
-            _ => {}
-        }
-
-        let args = obj
-            .get("args")
-            .and_then(Value::as_array)
-            .map(|arr| arr.iter().filter_map(|v| v.as_str().map(str::to_owned)).collect())
-            .unwrap_or_default();
-
-        out.insert(
-            name.to_owned(),
-            AgentMcpServer {
-                transport,
-                enabled: !disabled,
-                command,
-                args,
-                env: parse_key_values_map(obj.get("env")),
-                url,
-                headers: parse_key_values_map(obj.get("headers")),
-                agents: Vec::new(),
-            },
-        );
-    }
-    out
-}
-
-fn parse_key_values_map(val: Option<&Value>) -> BTreeMap<String, String> {
-    match val {
-        Some(Value::Object(map)) => map
-            .iter()
-            .filter_map(|(k, v)| {
-                let s = match v {
-                    Value::String(s) => s.clone(),
-                    Value::Number(n) => n.to_string(),
-                    Value::Bool(b) => b.to_string(),
-                    _ => return None,
-                };
-                Some((k.clone(), s))
-            })
-            .collect(),
-        Some(Value::Array(arr)) => arr
-            .iter()
-            .filter_map(|item| {
-                let obj = item.as_object()?;
-                let name = obj.get("name")?.as_str()?.to_owned();
-                let value = obj.get("value")?.as_str()?.to_owned();
-                Some((name, value))
-            })
-            .collect(),
-        _ => BTreeMap::new(),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn crud_and_acp_filtering_by_scope_agent_and_transport() {
-        let mut user = BTreeMap::new();
-        let mut workspace = BTreeMap::new();
-
-        apply_save(
-            &mut user,
-            &mut workspace,
-            true,
-            McpServerInput {
-                id: None,
-                name: "shared".into(),
-                scope: McpScope::User,
-                transport: McpTransport::Stdio,
-                enabled: true,
-                command: Some("npx".into()),
-                args: vec!["-y".into(), "user-pkg".into()],
-                env: vec![McpKeyValue { name: "TOKEN".into(), value: "u1".into() }],
-                url: None,
-                headers: Vec::new(),
-                agents: Vec::new(),
-            },
-        )
-        .unwrap();
-
-        apply_save(
-            &mut user,
-            &mut workspace,
-            true,
-            McpServerInput {
-                id: None,
-                name: "shared".into(),
-                scope: McpScope::Workspace,
-                transport: McpTransport::Stdio,
-                enabled: true,
-                command: Some("npx".into()),
-                args: vec!["-y".into(), "workspace-pkg".into()],
-                env: Vec::new(),
-                url: None,
-                headers: Vec::new(),
-                agents: Vec::new(),
-            },
-        )
-        .unwrap();
-
-        apply_save(
-            &mut user,
-            &mut workspace,
-            true,
-            McpServerInput {
-                id: None,
-                name: "claude-http".into(),
-                scope: McpScope::User,
-                transport: McpTransport::Http,
-                enabled: true,
-                command: None,
-                args: Vec::new(),
-                env: Vec::new(),
-                url: Some("https://example.com/mcp".into()),
-                headers: vec![McpKeyValue { name: "Authorization".into(), value: "Bearer secret".into() }],
-                agents: vec!["claude".into()],
-            },
-        )
-        .unwrap();
-
-        let list = servers_from_settings(&user, &workspace);
-        assert_eq!(list.len(), 3);
-
-        // Negotiated with HTTP support: `claude` gets workspace `shared` + `claude-http`; `codex` only gets `shared`.
-        let init_http = Negotiated::from_initialize(&json!({
-            "agentCapabilities": { "mcpCapabilities": { "http": true, "sse": false } }
-        }));
-        let claude_servers = acp_mcp_servers(&list, "claude-acp", &init_http);
-        assert_eq!(claude_servers.len(), 2);
-        assert_eq!(claude_servers[0]["name"], "shared");
-        assert_eq!(claude_servers[0]["args"], json!(["-y", "workspace-pkg"]));
-        assert_eq!(claude_servers[1]["name"], "claude-http");
-        assert_eq!(claude_servers[1]["type"], "http");
-
-        let codex_servers = acp_mcp_servers(&list, "codex", &init_http);
-        assert_eq!(codex_servers.len(), 1);
-        assert_eq!(codex_servers[0]["name"], "shared");
-
-        // Disable workspace `shared` and remove user `claude-http`.
-        apply_set_enabled(&mut user, &mut workspace, "workspace::shared", false).unwrap();
-        apply_remove(&mut user, &mut workspace, "user::claude-http").unwrap();
-        let list = servers_from_settings(&user, &workspace);
-        let after = acp_mcp_servers(&list, "claude", &init_http);
-        assert_eq!(after.len(), 1);
-        assert_eq!(after[0]["args"], json!(["-y", "user-pkg"]));
-    }
-
-    #[test]
-    fn imports_from_mcp_json_and_vscode_mcp_json_without_modifying_them() {
-        let tmp = tempfile::tempdir().unwrap();
-        let mcp_json = tmp.path().join(".mcp.json");
-        let vscode_dir = tmp.path().join(".vscode");
-        std::fs::create_dir_all(&vscode_dir).unwrap();
-        let vscode_mcp = vscode_dir.join("mcp.json");
-
-        let raw_mcp = r#"{"mcpServers":{"sqlite":{"command":"uvx","args":["mcp-server-sqlite"]}}}"#;
-        let raw_vscode = r#"{"servers":{"remote":{"type":"http","url":"https://mcp.example.com"}}}"#;
-        std::fs::write(&mcp_json, raw_mcp).unwrap();
-        std::fs::write(&vscode_mcp, raw_vscode).unwrap();
-
-        let mut workspace = BTreeMap::new();
-        let added = apply_import(&mut workspace, tmp.path());
-        assert_eq!(added, 2);
-        assert_eq!(workspace["sqlite"].command.as_deref(), Some("uvx"));
-        assert_eq!(workspace["remote"].transport, McpTransport::Http);
-        assert_eq!(workspace["remote"].url.as_deref(), Some("https://mcp.example.com"));
-
-        // Re-importing does not duplicate or overwrite existing entries, and leaves files untouched.
-        workspace.get_mut("sqlite").unwrap().enabled = false;
-        assert_eq!(apply_import(&mut workspace, tmp.path()), 0);
-        assert!(!workspace["sqlite"].enabled);
-        assert_eq!(std::fs::read_to_string(&mcp_json).unwrap(), raw_mcp);
-        assert_eq!(std::fs::read_to_string(&vscode_mcp).unwrap(), raw_vscode);
-    }
-}
@@ -34,8 +34,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 +89,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.
@@ -156,14 +138,6 @@ pub struct AgentConfigOption {
    pub via: AgentConfigVia,
 }

-#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub enum AgentCommandSource {
-    #[default]
-    Command,
-    Skill,
-}
-
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct AgentCommand {
@@ -172,8 +146,6 @@ pub struct AgentCommand {
    pub description: String,
    /// What to type after the command, when it takes input.
    pub hint: Option<String>,
-    #[serde(default)]
-    pub source: AgentCommandSource,
 }

 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
@@ -288,31 +260,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")]
@@ -385,10 +332,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>,
    },
@@ -419,9 +362,6 @@ pub struct AgentProvider {
    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,
@@ -518,15 +458,6 @@ pub enum AgentEvent {
        index: u32,
        entry: AgentEntry,
    },
-    /// Text was appended to entry `index` (an agent message or a thought): it read the first
-    /// `from` UTF-16 units of its text when the previous event for it was sent.
-    Append {
-        task: String,
-        subagent: Option<String>,
-        index: u32,
-        from: u32,
-        text: String,
-    },
    /// An agent reported the usage limits of its account (shared by every task of `provider`).
    Limits {
        provider: String,
@@ -535,70 +466,3 @@ pub enum AgentEvent {
    /// The installed or configured agent providers changed.
    Providers,
 }
-
-pub use ide_core::settings::{AgentMcpServer, McpTransport};
-
-/// Where an MCP server configuration is stored (`settings.toml` vs `.openidea/settings.toml`).
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub enum McpScope {
-    User,
-    Workspace,
-}
-
-/// A named environment variable or HTTP header for an MCP server.
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub struct McpKeyValue {
-    pub name: String,
-    pub value: String,
-}
-
-/// One configured Model Context Protocol (MCP) server.
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub struct McpServer {
-    pub id: String,
-    pub name: String,
-    pub scope: McpScope,
-    pub transport: McpTransport,
-    pub enabled: bool,
-    pub command: Option<String>,
-    pub args: Vec<String>,
-    pub env: Vec<McpKeyValue>,
-    pub url: Option<String>,
-    pub headers: Vec<McpKeyValue>,
-    /// Agent provider ids this server is enabled for; empty means enabled for all agents.
-    #[serde(default)]
-    pub agents: Vec<String>,
-}
-
-/// Payload for creating or updating a user or workspace MCP server.
-#[derive(Clone, Debug, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub struct McpServerInput {
-    #[serde(default)]
-    pub id: Option<String>,
-    pub name: String,
-    pub scope: McpScope,
-    pub transport: McpTransport,
-    #[serde(default = "default_true")]
-    pub enabled: bool,
-    #[serde(default)]
-    pub command: Option<String>,
-    #[serde(default)]
-    pub args: Vec<String>,
-    #[serde(default)]
-    pub env: Vec<McpKeyValue>,
-    #[serde(default)]
-    pub url: Option<String>,
-    #[serde(default)]
-    pub headers: Vec<McpKeyValue>,
-    /// Agent provider ids this server is enabled for; empty means enabled for all agents.
-    #[serde(default)]
-    pub agents: Vec<String>,
-}
-
-fn default_true() -> bool {
-    true
-}
@@ -135,7 +135,7 @@ impl Cli for Process {
 }

 /// Claude Code's configuration directory (`CLAUDE_CONFIG_DIR`, else `~/.claude`).
-pub(crate) fn config_dir(env: &[(String, String)]) -> Option<PathBuf> {
+pub(super) fn config_dir(env: &[(String, String)]) -> Option<PathBuf> {
    let set = env
        .iter()
        .find(|(k, _)| k == "CLAUDE_CONFIG_DIR")
@@ -31,11 +31,11 @@ pub(super) fn transcript(config_dir: &Path, cwd: &Path, id: &str) -> PathBuf {
 }

 /// The project directory name Claude Code uses for `cwd`.
-pub(crate) fn escape(cwd: &Path) -> String {
+pub(super) fn escape(cwd: &Path) -> String {
    cwd.to_string_lossy().chars().map(|c| if c.is_ascii_alphanumeric() { c } else { '-' }).collect()
 }

-pub(crate) fn read(path: &Path) -> std::io::Result<Vec<Value>> {
+pub(super) fn read(path: &Path) -> std::io::Result<Vec<Value>> {
    let text = std::fs::read_to_string(path)?;
    Ok(text.lines().filter_map(|l| serde_json::from_str(l).ok()).collect())
 }
@@ -111,7 +111,7 @@ fn block_ids<'a>(e: &'a Value, ty: &'a str, key: &'a str) -> impl Iterator<Item

 /// Whether `e` is a message that started a turn: the user's own, not a tool result, a
 /// steer, or text Claude Code added.
-pub(crate) fn is_turn_start(e: &Value) -> bool {
+pub(super) fn is_turn_start(e: &Value) -> bool {
    if kind(e) != "user" || e.get("isMeta").and_then(Value::as_bool) == Some(true) {
        return false;
    }
@@ -149,7 +149,7 @@ pub(super) fn cut(chain: &[&Value], turns: usize) -> Result<Option<String>, Stri
 }

 /// The newest title Claude Code gave the session.
-pub(crate) fn title(entries: &[Value]) -> Option<String> {
+pub(super) fn title(entries: &[Value]) -> Option<String> {
    entries
        .iter()
        .rev()
@@ -7,8 +7,8 @@
 //! <id>.json`): loading that session, from this connection or a fresh one, starts it that
 //! way.

-pub(crate) mod cli;
-pub(crate) mod history;
+mod cli;
+mod history;
 mod settings;
 mod tools;
 mod translate;
@@ -69,75 +69,6 @@ pub(crate) fn connect(
    Ok(super::serve(shim, client))
 }

-/// What discovery found: ACP `availableCommands`, `configOptions` for the configured model,
-/// and each model's effort option by model value (`None`: none).
-pub(crate) struct Discovered {
-    pub commands: Vec<Value>,
-    pub options: Value,
-    pub efforts: Vec<(String, Option<Value>)>,
-}
-
-/// Discover the slash commands and the model, mode and effort options without a prompt,
-/// ACP session, or pending session file.
-pub(crate) async fn discover(spec: ProviderSpec, cwd: PathBuf) -> Result<Discovered, String> {
-    tokio::time::timeout(Duration::from_secs(5), async move {
-        let spec = tokio::task::spawn_blocking(move || (spec.resolve_for_launch(&cwd), cwd));
-        let (spec, cwd) = spec.await.map_err(|e| e.to_string())?;
-        let mut args = spec.args;
-        args.extend(Start::New { id: uuid::Uuid::new_v4().to_string() }.args());
-        let launch = Launch { program: spec.command, args, cwd, env: spec.env };
-        let mut io = cli::Process.launch(&launch, Arc::new(|_| {})).map_err(|e| e.to_string())?;
-        let _stop = io.kill.clone().drop_guard();
-        let mut lines = BufReader::new(io.stdout).lines();
-        let init = control(
-            &mut io.stdin,
-            &mut lines,
-            "commands",
-            json!({ "subtype": "initialize", "perTaskStopAffordance": true }),
-        )
-        .await?
-        .ok_or("Claude Code did not initialize")?;
-        // The effort and model the user configured; without them the options show the defaults.
-        let applied = tokio::time::timeout(
-            Duration::from_secs(2),
-            control(&mut io.stdin, &mut lines, "settings", json!({ "subtype": "get_settings" })),
-        )
-        .await
-        .ok()
-        .and_then(Result::ok)
-        .flatten()
-        .unwrap_or_default();
-        let settings = Settings::from_cli(&init, &applied);
-        Ok(Discovered {
-            commands: settings.commands.clone(),
-            options: settings.options(),
-            efforts: settings.efforts_by_model(),
-        })
-    })
-    .await
-    .map_err(|_| "Claude Code command discovery timed out".to_owned())?
-}
-
-/// Sends one control request and waits for its response; `None` when the CLI answered with an error.
-async fn control(
-    stdin: &mut (impl AsyncWriteExt + Unpin),
-    lines: &mut tokio::io::Lines<impl AsyncBufReadExt + Unpin>,
-    id: &str,
-    request: Value,
-) -> Result<Option<Value>, String> {
-    let line = json!({ "type": "control_request", "request_id": id, "request": request });
-    stdin.write_all(format!("{line}\n").as_bytes()).await.map_err(|e| e.to_string())?;
-    stdin.flush().await.map_err(|e| e.to_string())?;
-    while let Some(line) = lines.next_line().await.map_err(|e| e.to_string())? {
-        let Ok(msg) = serde_json::from_str::<Value>(&line) else { continue };
-        if msg["type"] == "control_response" && msg["response"]["request_id"] == id {
-            let response = &msg["response"];
-            return Ok((response["subtype"] == "success").then(|| response["response"].clone()));
-        }
-    }
-    Err("Claude Code exited".into())
-}
-
 struct Config {
    pub program: String,
    /// Extra arguments (a custom agent's), before the session's own.
@@ -167,7 +98,6 @@ pub(super) struct Shim {
 struct Session {
    id: String,
    cwd: PathBuf,
-    mcp_config: Option<tempfile::TempPath>,
    shim: Weak<Shim>,
    st: Mutex<State>,
    /// Serializes (re)starting the process.
@@ -334,24 +264,9 @@ impl Shim {
        Ok(history::chain(&entries, at.as_deref()).into_iter().cloned().collect())
    }

-    fn add_session(
-        self: &Arc<Self>,
-        id: &str,
-        cwd: PathBuf,
-        start: Start,
-        pending: bool,
-        mcp_config: Option<String>,
-    ) -> Arc<Session> {
-        let mcp_config = mcp_config.and_then(|json| match write_mcp_config(&json) {
-            Ok(path) => Some(path),
-            Err(e) => {
-                tracing::warn!("Claude Code session {id}: cannot write its MCP configuration: {e}");
-                None
-            }
-        });
+    fn add_session(self: &Arc<Self>, id: &str, cwd: PathBuf, start: Start, pending: bool) -> Arc<Session> {
        let session = Arc::new(Session {
            id: id.to_owned(),
-            mcp_config,
            shim: Arc::downgrade(self),
            st: Mutex::new(State {
                proc: None,
@@ -397,8 +312,7 @@ impl Shim {
                        "loadSession": true,
                        "promptCapabilities": { "image": true, "embeddedContext": true },
                        "sessionCapabilities": { "fork": {} },
-                        "mcpCapabilities": { "stdio": true, "http": true, "sse": true },
-                        "_meta": { "openidea": { "rollback": true, "steer": true, "backgroundTasks": true } },
+                        "_meta": { "openidea": { "rollback": true, "steer": true } },
                    },
                    "agentInfo": { "name": "claude", "title": "Claude Code", "version": self.version() },
                    "authMethods": [],
@@ -406,13 +320,7 @@ impl Shim {
            }
            "session/new" => {
                let id = new_uuid(false);
-                let session = self.add_session(
-                    &id,
-                    self.cwd_of(&params),
-                    Start::New { id: id.clone() },
-                    false,
-                    mcp_config(&params),
-                );
+                let session = self.add_session(&id, self.cwd_of(&params), Start::New { id: id.clone() }, false);
                rt.block_on(session.ensure()).map_err(|e| self.start_error(&session, e))?;
                session.announce_commands();
                Ok(json!({ "sessionId": id, "configOptions": session.st.lock().settings.options() }))
@@ -428,7 +336,7 @@ impl Shim {
                    None => return Err(invalid(format!("no Claude Code session {id} in {}", cwd.display()))),
                };
                let chain = self.base_chain(&cwd, &start).map_err(internal)?;
-                let session = self.add_session(id, cwd, start, pending, mcp_config(&params));
+                let session = self.add_session(id, cwd, start, pending);
                rt.block_on(session.ensure()).map_err(|e| self.start_error(&session, e))?;
                if method == "session/load" {
                    session.replay(&chain);
@@ -454,7 +362,7 @@ impl Shim {
                    (start, st.settings.clone())
                };
                self.save_pending(&id, Some(&start));
-                let session = self.add_session(&id, source.cwd.clone(), start, true, mcp_config(&params));
+                let session = self.add_session(&id, source.cwd.clone(), start, true);
                session.st.lock().settings = settings;
                let options = session.st.lock().settings.options();
                Ok(json!({ "sessionId": id, "configOptions": options }))
@@ -488,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;
@@ -648,9 +549,6 @@ impl Session {
            old.end();
        }
        let mut args = shim.config.args.clone();
-        if let Some(config) = &self.mcp_config {
-            args.extend(["--mcp-config".to_owned(), config.to_string_lossy().into_owned()]);
-        }
        args.extend(start.args());
        let launch =
            Launch { program: shim.config.program.clone(), args, cwd: self.cwd.clone(), env: shim.config.env.clone() };
@@ -713,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();
@@ -1212,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 {
@@ -1440,38 +1329,3 @@ fn start_from_json(v: &Value) -> Option<Start> {
    }
    Some(Start::Fork { from: s("fork")?, id: s("id")?, at: s("at") })
 }
-
-/// Writes `json` to a new file only this user can read (removed when the path is dropped).
-fn write_mcp_config(json: &str) -> std::io::Result<tempfile::TempPath> {
-    let mut file = tempfile::Builder::new().prefix("openidea-mcp-").suffix(".json").tempfile()?;
-    std::io::Write::write_all(&mut file, json.as_bytes())?;
-    Ok(file.into_temp_path())
-}
-
-/// ACP `mcpServers` as Claude Code's `--mcp-config` JSON (`None` when there are none).
-fn mcp_config(params: &Value) -> Option<String> {
-    let servers = params.get("mcpServers")?.as_array()?;
-    let pairs = |v: Option<&Value>| -> serde_json::Map<String, Value> {
-        v.and_then(Value::as_array)
-            .into_iter()
-            .flatten()
-            .filter_map(|p| Some((p.get("name")?.as_str()?.to_owned(), p.get("value")?.clone())))
-            .collect()
-    };
-    let mut out = serde_json::Map::new();
-    for server in servers {
-        let Some(name) = server.get("name").and_then(Value::as_str) else { continue };
-        let entry = match server.get("type").and_then(Value::as_str) {
-            Some(kind @ ("http" | "sse")) => {
-                json!({ "type": kind, "url": server.get("url"), "headers": pairs(server.get("headers")) })
-            }
-            _ => json!({
-                "command": server.get("command"),
-                "args": server.get("args").cloned().unwrap_or_else(|| json!([])),
-                "env": pairs(server.get("env")),
-            }),
-        };
-        out.insert(name.to_owned(), entry);
-    }
-    (!out.is_empty()).then(|| json!({ "mcpServers": out }).to_string())
-}
@@ -132,18 +132,19 @@ impl Settings {
                }).collect::<Vec<_>>(),
            }));
        }
-        if let Some(effort) = self.current_model().and_then(|m| effort_option(m, &self.effort)) {
-            out.push(effort);
+        let efforts = self.current_model().map(|m| m.efforts.as_slice()).unwrap_or_default();
+        if !efforts.is_empty() {
+            let mut values = vec![json!({ "value": "default", "name": "Default" })];
+            values.extend(efforts.iter().map(|e| json!({ "value": e, "name": capitalize(e) })));
+            let current = if efforts.contains(&self.effort) { self.effort.as_str() } else { "default" };
+            out.push(json!({
+                "id": EFFORT, "name": "Effort", "category": "thought_level", "type": "select",
+                "currentValue": current, "options": values,
+            }));
        }
        Value::Array(out)
    }

-    /// Each model's effort option by model value (`None`: it has no effort levels): what a new
-    /// task offers once that model is picked, before any session has run it.
-    pub fn efforts_by_model(&self) -> Vec<(String, Option<Value>)> {
-        self.models.iter().map(|m| (m.value.clone(), effort_option(m, &self.effort))).collect()
-    }
-
    pub fn valid(&self, option: &str, value: &str) -> bool {
        self.options()
            .as_array()
@@ -155,20 +156,6 @@ impl Settings {
    }
 }

-/// `model`'s effort option, with `effort` selected when the model offers it; `None` without efforts.
-fn effort_option(model: &Model, effort: &str) -> Option<Value> {
-    if model.efforts.is_empty() {
-        return None;
-    }
-    let mut values = vec![json!({ "value": "default", "name": "Default" })];
-    values.extend(model.efforts.iter().map(|e| json!({ "value": e, "name": capitalize(e) })));
-    let current = if model.efforts.iter().any(|e| e == effort) { effort } else { "default" };
-    Some(json!({
-        "id": EFFORT, "name": "Effort", "category": "thought_level", "type": "select",
-        "currentValue": current, "options": values,
-    }))
-}
-
 /// Slash commands as ACP `availableCommands`, without those that need Claude Code's terminal.
 pub(super) fn commands(list: Option<&Value>, terminal_only: &[String]) -> Vec<Value> {
    list.and_then(Value::as_array)
@@ -244,20 +231,4 @@ mod tests {
        let cmds = commands(init().get("commands"), &["doctor".into()]);
        assert_eq!(cmds, vec![json!({"name": "review", "description": "Review", "input": {"hint": "[pr]"}})]);
    }
-
-    #[test]
-    fn every_model_offers_its_own_efforts() {
-        let s = Settings::from_cli(&init(), &json!({"applied": {"model": "claude-sonnet-5-5", "effort": "high"}}));
-        let efforts = s.efforts_by_model();
-        let values = |model: &str| {
-            let (_, o) = efforts.iter().find(|(m, _)| m == model).unwrap();
-            let o = o.as_ref().unwrap();
-            let values: Vec<_> = o["options"].as_array().unwrap().iter().map(|v| v["value"].clone()).collect();
-            (values, o["currentValue"].clone())
-        };
-        assert_eq!(values("default"), (vec![json!("default"), json!("low"), json!("high")], json!("high")));
-        // The configured effort only where the model offers it.
-        assert_eq!(values("opus"), (vec![json!("default"), json!("low"), json!("max")], json!("default")));
-        assert!(efforts.contains(&("claude-haiku-4-5".into(), None)), "no effort option without levels");
-    }
 }
@@ -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,93 +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);
-}
-
-#[test]
-fn mcp_servers_become_an_mcp_config() {
-    assert_eq!(mcp_config(&json!({ "mcpServers": [] })), None);
-    assert_eq!(mcp_config(&json!({})), None);
-    let config = mcp_config(&json!({ "mcpServers": [
-        { "type": "http", "name": "openidea", "url": "http://127.0.0.1:1/mcp",
-          "headers": [{ "name": "Authorization", "value": "Bearer t" }] },
-        { "name": "local", "command": "srv", "args": ["-x"], "env": [{ "name": "K", "value": "V" }] },
-    ] }))
-    .unwrap();
-    let v: Value = serde_json::from_str(&config).unwrap();
-    assert_eq!(
-        v["mcpServers"]["openidea"],
-        json!({ "type": "http", "url": "http://127.0.0.1:1/mcp", "headers": { "Authorization": "Bearer t" } })
-    );
-    assert_eq!(v["mcpServers"]["local"], json!({ "command": "srv", "args": ["-x"], "env": { "K": "V" } }));
-
-    let path = write_mcp_config(&config).unwrap();
-    assert_eq!(std::fs::read_to_string(&path).unwrap(), config);
-    #[cfg(unix)]
-    assert_eq!(std::os::unix::fs::PermissionsExt::mode(&std::fs::metadata(&path).unwrap().permissions()) & 0o077, 0);
-    let kept = path.to_path_buf();
-    drop(path);
-    assert!(!kept.exists());
-}
@@ -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(),
        }
    }
@@ -8,7 +8,6 @@ mod translate;
 mod tests;

 use super::Shim;
-use crate::acp::AUTH_REQUIRED;
 use crate::provider::ProviderSpec;
 use ide_jsonrpc::{Framing, Handler, Peer, RpcError, codes};
 use parking_lot::Mutex;
@@ -28,6 +27,8 @@ const OUTPUT_EVERY: Duration = Duration::from_millis(200);
 const EARLY_CANCEL: Duration = Duration::from_secs(1);
 /// How long the client's connection outlives codex.
 const EXIT_GRACE: Duration = Duration::from_millis(100);
+/// ACP's error code for a request that needs the user to sign in.
+const AUTH_REQUIRED: i64 = -32000;

 pub(crate) fn connect(
    spec: &ProviderSpec,
@@ -53,7 +54,6 @@ fn attach(
        client: OnceLock::new(),
        state: Mutex::new(State::default()),
        models: tokio::sync::Mutex::new(None),
-        skills: tokio::sync::Mutex::new(()),
    });
    let codex = connect_codex(Arc::new(CodexEvents(Arc::downgrade(&shim))))?;
    let _ = shim.codex.set(codex.clone());
@@ -83,8 +83,6 @@ struct CodexShim {
    state: Mutex<State>,
    /// `model/list`, fetched once.
    models: tokio::sync::Mutex<Option<Arc<Vec<ModelInfo>>>>,
-    /// Keep skill snapshots in request order, including invalidations during session setup.
-    skills: tokio::sync::Mutex<()>,
 }

 #[derive(Default)]
@@ -206,7 +204,7 @@ fn from_codex(e: RpcError) -> ResponseError {
                code,
                codes::PARSE_ERROR | codes::INVALID_REQUEST | codes::METHOD_NOT_FOUND | codes::INVALID_PARAMS
            );
-            let code = if !protocol && crate::acp::auth_required(code, &message) { AUTH_REQUIRED } else { code };
+            let code = if !protocol && message.to_lowercase().contains("auth") { AUTH_REQUIRED } else { code };
            ResponseError { code, message, data }
        }
        RpcError::Closed => error(codes::INTERNAL_ERROR, "Codex exited"),
@@ -266,7 +264,7 @@ impl CodexShim {
            "agentCapabilities": {
                "loadSession": true,
                "promptCapabilities": { "image": true, "audio": false, "embeddedContext": true },
-                "mcpCapabilities": { "http": false, "sse": false, "stdio": true },
+                "mcpCapabilities": { "http": false, "sse": false },
                "sessionCapabilities": { "fork": {}, "close": {} },
                "_meta": { "openidea": { "rollback": true, "steer": true } },
            },
@@ -303,20 +301,6 @@ impl CodexShim {
        models
    }

-    async fn publish_skills(&self, session: &str) {
-        let _listing = self.skills.lock().await;
-        let cwd = self.state.lock().threads.get(session).and_then(|t| t.cwd.clone());
-        let Some(cwd) = cwd else { return };
-        let result =
-            tokio::time::timeout(Duration::from_secs(5), self.call("skills/list", json!({ "cwds": [cwd] }))).await;
-        if let Ok(Ok(result)) = result
-            && let Some(update) = translate::skill_commands(&result)
-            && self.state.lock().threads.contains_key(session)
-        {
-            self.emit(session, update);
-        }
-    }
-
    /// Registers a thread codex opened for a session of its own; returns its `configOptions`.
    fn open_thread(&self, result: &Value, models: &[ModelInfo], settings: Option<Settings>) -> (String, Value) {
        let thread = result.get("thread").unwrap_or(&Value::Null);
@@ -334,16 +318,11 @@ impl CodexShim {

    async fn new_session(&self, params: &Value) -> Result<Value, ResponseError> {
        let models = self.models().await;
-        let mut request = json!({ "cwd": params.get("cwd") });
-        if let Some(config) = translate::mcp_config(params) {
-            request["config"] = config;
-        }
-        let result = self.call("thread/start", request).await?;
+        let result = self.call("thread/start", json!({ "cwd": params.get("cwd") })).await?;
        let (id, options) = self.open_thread(&result, &models, None);
        if id.is_empty() {
            return Err(error(codes::INTERNAL_ERROR, "codex started no thread"));
        }
-        self.publish_skills(&id).await;
        Ok(json!({ "sessionId": id, "configOptions": options }))
    }

@@ -351,18 +330,13 @@ impl CodexShim {
    async fn load_session(&self, params: &Value) -> Result<Value, ResponseError> {
        let id = str_param(params, "sessionId")?;
        let models = self.models().await;
-        let mut request = json!({ "threadId": id, "cwd": params.get("cwd") });
-        if let Some(config) = translate::mcp_config(params) {
-            request["config"] = config;
-        }
-        let result = self.call("thread/resume", request).await?;
+        let result = self.call("thread/resume", json!({ "threadId": id, "cwd": params.get("cwd") })).await?;
        let (_, options) = self.open_thread(&result, &models, None);
        let cwd = self.state.lock().threads.get(id).and_then(|t| t.cwd.clone());
        let thread = result.get("thread").unwrap_or(&Value::Null);
        for update in translate::history(thread, cwd.as_deref()) {
            self.emit(id, update);
        }
-        self.publish_skills(id).await;
        Ok(json!({ "configOptions": options }))
    }

@@ -371,9 +345,6 @@ impl CodexShim {
        let models = self.models().await;
        let settings = self.state.lock().threads.get(source).and_then(|t| t.settings.clone());
        let mut request = json!({ "threadId": source, "cwd": params.get("cwd") });
-        if let Some(config) = translate::mcp_config(params) {
-            request["config"] = config;
-        }
        if let Some(s) = &settings {
            request["model"] = json!(s.model_slug(&models));
            request["approvalPolicy"] = json!(s.mode.approval_policy());
@@ -381,7 +352,6 @@ impl CodexShim {
        }
        let result = self.call("thread/fork", request).await?;
        let (id, options) = self.open_thread(&result, &models, settings);
-        self.publish_skills(&id).await;
        Ok(json!({ "sessionId": id, "configOptions": options }))
    }

@@ -571,25 +541,9 @@ impl CodexShim {
        }
    }

-    fn on_codex_notification(self: &Arc<Self>, method: &str, params: &Value) {
+    fn on_codex_notification(&self, method: &str, params: &Value) {
        let thread = params.get("threadId").and_then(Value::as_str).unwrap_or_default();
        match method {
-            "skills/changed" => {
-                let shim = self.clone();
-                let sessions: Vec<String> = self
-                    .state
-                    .lock()
-                    .threads
-                    .iter()
-                    .filter(|(_, t)| t.settings.is_some() && t.parent.is_none())
-                    .map(|(id, _)| id.clone())
-                    .collect();
-                self.runtime.spawn(async move {
-                    for session in sessions {
-                        shim.publish_skills(&session).await;
-                    }
-                });
-            }
            "turn/started" => {
                if let Some(turn) = params.pointer("/turn/id").and_then(Value::as_str) {
                    self.turn_known(thread, turn, true);
@@ -868,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,
@@ -917,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 }))
@@ -998,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,
@@ -528,21 +469,12 @@ async fn play<R: AsyncRead + Unpin, W: AsyncWrite + Unpin>(
    let mut sent = Vec::new();
    for (out, frame) in &t.frames {
        if *out {
-            let actual: Value = loop {
-                let line = tokio::time::timeout(Duration::from_secs(10), lines.next_line())
-                    .await
-                    .unwrap_or_else(|_| panic!("the shim didn't send {frame}"))
-                    .unwrap()
-                    .unwrap_or_else(|| panic!("the shim closed before {frame}"));
-                let actual: Value = serde_json::from_str(&line).unwrap();
-                // Older recordings predate skill discovery; play an unsupported server.
-                if actual["method"] == "skills/list" && frame["method"] != "skills/list" {
-                    let reply = json!({ "id": actual["id"], "error": { "code": -32601, "message": "unsupported" } });
-                    write.write_all(format!("{reply}\n").as_bytes()).await.unwrap();
-                    continue;
-                }
-                break actual;
-            };
+            let line = tokio::time::timeout(Duration::from_secs(10), lines.next_line())
+                .await
+                .unwrap_or_else(|_| panic!("the shim didn't send {frame}"))
+                .unwrap()
+                .unwrap_or_else(|| panic!("the shim closed before {frame}"));
+            let actual: Value = serde_json::from_str(&line).unwrap();
            match frame.get("method") {
                Some(method) => {
                    assert_eq!(actual.get("method"), Some(method), "expected {frame}, got {actual}");
@@ -632,23 +564,6 @@ async fn auth_failure_names_auth() {
    assert!(start.get("jsonrpc").is_some(), "codex accepts the jsonrpc field");
 }

-#[test]
-fn request_errors_classify_authentication_without_matching_author_or_protocol_errors() {
-    for (code, message, expected) in [
-        (codes::INTERNAL_ERROR, "Missing author field", codes::INTERNAL_ERROR),
-        (codes::INTERNAL_ERROR, "Unknown authority", codes::INTERNAL_ERROR),
-        (codes::INTERNAL_ERROR, "Authentication failed: expired token", AUTH_REQUIRED),
-        (codes::INTERNAL_ERROR, "Unauthorized", AUTH_REQUIRED),
-        (codes::METHOD_NOT_FOUND, "authentication method not found", codes::METHOD_NOT_FOUND),
-        (AUTH_REQUIRED, "Account is not eligible", AUTH_REQUIRED),
-    ] {
-        let response = from_codex(RpcError::Server { code, message: message.into(), data: Some(json!({"detail": 1})) });
-        assert_eq!(response.code, expected, "{message}");
-        assert_eq!(response.message, message);
-        assert_eq!(response.data, Some(json!({"detail": 1})));
-    }
-}
-
 #[tokio::test(flavor = "multi_thread")]
 async fn a_stop_sent_right_after_the_prompt_interrupts_the_turn() {
    let (results, _client, frames, _) = replay(Scenario::Interrupt).await;
@@ -1053,129 +968,3 @@ fn v_method(line: &str) -> Option<&str> {
    let at = line.find("\"method\":\"")? + 10;
    line[at..].split('"').next()
 }
-
-#[test]
-fn session_mcp_servers_become_thread_configuration() {
-    assert!(mcp_config(&json!({"mcpServers":[]})).is_none());
-    assert_eq!(
-        mcp_config(&json!({"mcpServers":[{"name":"OpenIDEA","command":"/app/openidea",
-        "args":["--mcp-stdio","--project","/project"],"env":[{"name":"K","value":"V"}]}]})),
-        Some(
-            json!({"mcp_servers":{"OpenIDEA":{"command":"/app/openidea","args":["--mcp-stdio","--project","/project"],"env":{"K":"V"}}}})
-        )
-    );
-}
-
-#[tokio::test(flavor = "multi_thread")]
-async fn skills_are_listed_for_sessions_and_refreshed_on_change() {
-    for (method, native) in
-        [("session/new", "thread/start"), ("session/load", "thread/resume"), ("session/fork", "thread/fork")]
-    {
-        for initial in [
-            json!({"result": {"data": [{"cwd": "/work", "errors": [], "skills": [
-                {"name": "review", "enabled": true, "description": "Review", "path": "/work/SKILL.md", "scope": "repo"}
-            ]}]}}),
-            json!({"error": {"code": -32601, "message": "unsupported"}}),
-            json!({"result": {}}),
-        ] {
-            let listed = initial.pointer("/result/data").is_some();
-            let mut initial = initial;
-            initial["id"] = json!(4);
-            let transcript = Transcript {
-                meta: Value::Null,
-                frames: vec![
-                    (true, json!({"id": 1, "method": "initialize"})),
-                    (false, json!({"id": 1, "result": {}})),
-                    (true, json!({"method": "initialized"})),
-                    (true, json!({"id": 2, "method": "model/list"})),
-                    (false, json!({"id": 2, "result": {"data": []}})),
-                    (true, json!({"id": 3, "method": native})),
-                    (
-                        false,
-                        json!({"id": 3, "result": {"thread": {"id": "s", "cwd": "/work", "turns": []}, "cwd": "/work"}}),
-                    ),
-                    (true, json!({"id": 4, "method": "skills/list"})),
-                    (false, initial),
-                    (true, json!({"id": 5, "method": "turn/start"})),
-                    (false, json!({"id": 5, "error": {"code": -32602, "message": "no model in this test"}})),
-                    (false, json!({"method": "skills/changed", "params": {}})),
-                    (true, json!({"id": 6, "method": "skills/list"})),
-                    (false, json!({"id": 6, "result": {"data": [{"cwd": "/work", "skills": [], "errors": []}]}})),
-                    (false, json!({"method": "skills/changed", "params": {}})),
-                    (true, json!({"id": 7, "method": "skills/list"})),
-                    (false, json!({"id": 7, "error": {"code": -32603, "message": "listing failed"}})),
-                    (false, json!({"method": "skills/changed", "params": {}})),
-                    (true, json!({"id": 8, "method": "skills/list"})),
-                    (false, json!({"id": 8, "result": {"data": []}})),
-                ],
-            };
-            let (ours, theirs) = tokio::io::duplex(1 << 16);
-            let client = Arc::new(Client::default());
-            let acp = attach(client.clone(), |events| {
-                let (read, write) = tokio::io::split(ours);
-                Ok(Peer::connect_framed(read, write, events, Framing::Lines))
-            })
-            .unwrap();
-            let (read, write) = tokio::io::split(theirs);
-            let player = tokio::spawn(async move { play(&transcript, read, write).await });
-            request(&acp, "initialize", json!({})).await.unwrap();
-            request(&acp, method, json!({"sessionId": "s", "cwd": "/work"})).await.unwrap();
-            let initial_updates = client.of("s");
-            assert_eq!(initial_updates.len(), usize::from(listed), "{method}");
-            if listed {
-                assert_eq!(initial_updates[0]["availableCommands"][0]["name"], "$review");
-                assert_eq!(initial_updates[0]["availableCommands"][0]["source"], "skill");
-            }
-            assert!(
-                request(&acp, "session/prompt", json!({"sessionId": "s", "prompt": text("/$review check this")}))
-                    .await
-                    .is_err()
-            );
-            let (frames, _read, _write) = player.await.unwrap();
-            for frame in sent(&frames, "skills/list") {
-                assert_eq!(frame["params"], json!({"cwds": ["/work"]}));
-            }
-            assert_eq!(
-                sent(&frames, "turn/start")[0]["params"]["input"],
-                json!([{"type": "text", "text": "/$review check this"}])
-            );
-            tokio::time::timeout(Duration::from_secs(5), async {
-                while client.of("s").len() < usize::from(listed) + 2 {
-                    tokio::task::yield_now().await;
-                }
-            })
-            .await
-            .unwrap();
-            let updates = client.of("s");
-            assert_eq!(updates.len(), usize::from(listed) + 2);
-            assert_eq!(updates.last().unwrap()["availableCommands"], json!([]));
-            acp.kill();
-        }
-    }
-}
-
-#[test]
-fn skills_become_commands_with_their_invocation_names() {
-    let update = skill_commands(&json!({"data": [{"skills": [
-        {"name": "review", "enabled": true, "description": "Long", "shortDescription": "Short"},
-        {"name": "review", "enabled": true, "description": "Duplicate"},
-        {"name": "hidden", "enabled": false, "description": "Disabled"},
-        {"name": "modern", "enabled": true, "description": "Long", "interface": {"shortDescription": "Modern"}},
-        {"name": "full", "enabled": true, "description": "Full description"},
-        {"name": "", "enabled": true}, {"description": "No name"}
-    ]}]}))
-    .unwrap();
-    assert_eq!(
-        update,
-        json!({"sessionUpdate": "available_commands_update", "availableCommands": [
-            {"name": "$review", "description": "Short", "source": "skill", "input": null},
-            {"name": "$modern", "description": "Modern", "source": "skill", "input": null},
-            {"name": "$full", "description": "Full description", "source": "skill", "input": null}
-        ]})
-    );
-    let commands = crate::config::commands_of(&update, "codex");
-    assert!(commands.iter().all(|c| c.source == crate::AgentCommandSource::Skill));
-    assert_eq!(commands[0].name, "$review");
-    assert!(skill_commands(&json!({"data": []})).unwrap()["availableCommands"].as_array().unwrap().is_empty());
-    assert!(skill_commands(&json!({})).is_none());
-}
@@ -256,31 +256,6 @@ fn effort_name(effort: &str) -> String {
    }
 }

-/// The enabled skills from `skills/list`, named as Codex ACP advertises them.
-pub(super) fn skill_commands(result: &Value) -> Option<Value> {
-    let entries = result.get("data")?.as_array()?;
-    let mut seen = std::collections::HashSet::new();
-    let commands: Vec<Value> = entries
-        .iter()
-        .filter_map(|entry| entry.get("skills").and_then(Value::as_array))
-        .flatten()
-        .filter_map(|skill| {
-            let name = skill.get("name")?.as_str()?.trim();
-            if name.is_empty() || skill.get("enabled") == Some(&Value::Bool(false)) || !seen.insert(name) {
-                return None;
-            }
-            let description = skill
-                .pointer("/interface/shortDescription")
-                .and_then(Value::as_str)
-                .or_else(|| skill.get("shortDescription").and_then(Value::as_str))
-                .or_else(|| skill.get("description").and_then(Value::as_str))
-                .unwrap_or(name);
-            Some(json!({ "name": format!("${name}"), "description": description, "source": "skill", "input": null }))
-        })
-        .collect();
-    Some(json!({ "sessionUpdate": "available_commands_update", "availableCommands": commands }))
-}
-
 /// ACP prompt content blocks as codex `UserInput`s. Embedded files become text.
 pub(super) fn user_input(prompt: &Value) -> Vec<Value> {
    let blocks = prompt.as_array().map(Vec::as_slice).unwrap_or_default();
@@ -758,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(),
    }
 }
@@ -861,31 +835,3 @@ pub(super) fn tail(text: &str) -> String {
 fn str_of(v: &Value, key: &str) -> Option<String> {
    v.get(key).and_then(Value::as_str).map(str::to_owned)
 }
-
-/// Session-scoped MCP configuration, carried in thread/start, resume and fork.
-pub(super) fn mcp_config(params: &Value) -> Option<Value> {
-    let mut servers = serde_json::Map::new();
-    for server in params.get("mcpServers")?.as_array()? {
-        if server.get("type").and_then(Value::as_str).is_some_and(|t| t != "stdio") {
-            continue;
-        }
-        let (Some(name), Some(command)) =
-            (server.get("name").and_then(Value::as_str), server.get("command").and_then(Value::as_str))
-        else {
-            continue;
-        };
-        let env: serde_json::Map<String, Value> = server
-            .get("env")
-            .and_then(Value::as_array)
-            .into_iter()
-            .flatten()
-            .filter_map(|v| Some((v.get("name")?.as_str()?.to_owned(), v.get("value")?.clone())))
-            .collect();
-        servers.insert(
-            name.into(),
-            json!({"command":command,
-            "args":server.get("args").cloned().unwrap_or_else(||json!([])),"env":env}),
-        );
-    }
-    (!servers.is_empty()).then(|| json!({"mcp_servers":servers}))
-}
@@ -5,7 +5,6 @@
 use crate::{AgentCommandReadOnlyReason, AgentProvider, AgentSource};
 use ide_core::{IdeError, IdeResult};
 use serde::{Deserialize, Serialize};
-use serde_json::Value;
 use std::collections::BTreeMap;
 use std::path::{Path, PathBuf};

@@ -59,14 +58,11 @@ const BUILTIN: &[(&str, &str, Driver, &[&str], &str)] = &[
    ("cursor", "Cursor", Driver::Acp, &["cursor-agent", "acp"], "Run `cursor-agent login` in a terminal."),
    ("opencode", "OpenCode", Driver::Acp, &["opencode", "acp"], "Run `opencode auth login` in a terminal."),
    ("qwen", "Qwen Code", Driver::Acp, &["qwen", "--experimental-acp"], "Run `qwen` in a terminal and sign in."),
-    ("qoder", "Qoder", Driver::Acp, &["qodercli", "--acp"], "Run `qodercli login` in a terminal."),
-    ("qodercn", "Qoder CN", Driver::Acp, &["qoderclicn", "--acp"], "Run `qoderclicn login` in a terminal."),
    ("kimi", "Kimi CLI", Driver::Acp, &["kimi", "acp"], "Run `kimi` in a terminal and sign in."),
    ("goose", "Goose", Driver::Acp, &["goose", "acp"], "Run `goose configure` in a terminal."),
    ("auggie", "Auggie", Driver::Acp, &["auggie", "--acp"], "Run `auggie login` in a terminal."),
    ("kiro", "Kiro", Driver::Acp, &["kiro-cli", "acp"], "Run `kiro-cli login` in a terminal."),
    ("vibe", "Mistral Vibe", Driver::Acp, &["vibe-acp"], "Run `vibe` in a terminal and sign in."),
-    ("omp", "OMP", Driver::Acp, &["omp", "acp"], "Run `omp` in a terminal and sign in."),
 ];

 fn builtins() -> Vec<ProviderSpec> {
@@ -85,91 +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, auth_methods: &[Value]) -> String {
-        let name = &self.name;
-        let program = Path::new(&self.command);
-        let terminal_args = matches!(self.source, AgentSource::Registry { .. })
-            .then(|| {
-                auth_methods.iter().find_map(|method| {
-                    if method.get("type").and_then(Value::as_str) != Some("terminal") {
-                        return None;
-                    }
-                    method.get("args")?.as_array()?.iter().map(Value::as_str).collect::<Option<Vec<_>>>()
-                })
-            })
-            .flatten();
-        let hint = match terminal_args {
-            Some(args) => {
-                let command = render_login_command(program, args, cfg!(windows));
-                format!("Run `{command}` in a terminal.")
-            }
-            None => self.login_hint(program),
-        };
-        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 (args, suffix) = rest.split_once('`').expect("built-in login hints delimit their command");
-    let command = render_login_command(program, args.split_whitespace(), windows);
-    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(),
-    }
-}
-
-fn render_login_command<'a>(program: &Path, args: impl IntoIterator<Item = &'a str>, windows: bool) -> String {
-    let quote = |word: &str| {
-        if windows { format!("'{}'", word.replace('\'', "''")) } else { format!("'{}'", word.replace('\'', "'\\''")) }
-    };
-    let mut command = format!("{}{}", if windows { "& " } else { "" }, quote(&program.to_string_lossy()));
-    for arg in args {
-        command.push(' ');
-        if !arg.is_empty() && arg.chars().all(|c| c.is_ascii_alphanumeric() || "-_=./".contains(c)) {
-            command.push_str(arg);
-        } else {
-            command.push_str(&quote(arg));
-        }
-    }
-    command
-}
-
 /// 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`.
@@ -187,14 +98,6 @@ pub(crate) fn builtin_spec(id: &str) -> Option<ProviderSpec> {
    builtins().into_iter().find(|s| s.id == id)
 }

-/// The ACP adapters of Claude Code and Codex, which the native drivers replace: they still
-/// launch, but are listed only once customized through an agent file or used by a task.
-const UNLISTED: &[&str] = &["claude-acp", "codex-acp"];
-
-pub(crate) fn is_unlisted(spec: &ProviderSpec) -> bool {
-    UNLISTED.contains(&spec.id.as_str()) && builtin_spec(&spec.id).as_ref() == Some(spec)
-}
-
 /// Public launch metadata, keeping the built-in defaults separate from agent-file overrides.
 pub(crate) fn describe(spec: &ProviderSpec) -> AgentProvider {
    let builtin = builtin_spec(&spec.id);
@@ -216,14 +119,13 @@ 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(),
    }
@@ -409,152 +311,6 @@ fn is_executable(p: &Path) -> bool {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use serde_json::json;
-
-    #[test]
-    fn qoder_global_and_cn_editions_are_both_built_in() {
-        let info = |id: &str| describe(&load(None).into_iter().find(|s| s.id == id).unwrap());
-        let (global, cn) = (info("qoder"), info("qodercn"));
-        assert_eq!((global.name.as_str(), global.command.as_str()), ("Qoder", "qodercli --acp"));
-        assert_eq!((cn.name.as_str(), cn.command.as_str()), ("Qoder CN", "qoderclicn --acp"));
-        assert_eq!(global.login_hint.as_deref(), Some("Run `qodercli login` in a terminal."));
-    }
-
-    #[test]
-    fn qodercn_is_available_without_a_file_and_preserves_existing_customizations() {
-        let dir = tempfile::tempdir().unwrap();
-        let qodercn = load(None).into_iter().find(|s| s.id == "qodercn").unwrap();
-        assert_eq!(qodercn.driver, Driver::Acp);
-        assert!(!is_unlisted(&qodercn));
-        let info = describe(&qodercn);
-        assert_eq!(info.name, "Qoder CN");
-        assert_eq!(info.command, "qoderclicn --acp");
-        assert_eq!(info.source, AgentSource::Builtin);
-        assert!(info.command_editable);
-        assert_eq!(info.login_hint.as_deref(), Some("Run `qoderclicn login` in a terminal."));
-
-        std::fs::write(
-            dir.path().join("qodercn.toml"),
-            "command = \"/custom/qoderclicn\"\nargs = [\"--acp\"]\n[env]\nK = \"v\"\n",
-        )
-        .unwrap();
-        let specs = load(Some(dir.path()));
-        assert_eq!(specs.iter().filter(|s| s.id == "qodercn").count(), 1);
-        let custom = specs.iter().find(|s| s.id == "qodercn").unwrap();
-        assert_eq!(custom.command, "/custom/qoderclicn");
-        assert_eq!(custom.env, [("K".into(), "v".into())]);
-        set_builtin_command(dir.path(), "qodercn", None).unwrap();
-        let reset = load(Some(dir.path())).into_iter().find(|s| s.id == "qodercn").unwrap();
-        assert_eq!(reset.command, "qoderclicn");
-        assert_eq!(reset.args, ["--acp"]);
-        assert_eq!(reset.env, custom.env);
-    }
-
-    #[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));
-    }
-
-    #[test]
-    fn terminal_login_commands_quote_the_binary_and_each_argument() {
-        for (windows, expected) in [
-            (false, "'/agent'\\''s tools/$cli' auth login --account 'user name' 'a'\\''b' '$token' ''"),
-            (true, "& '/agent''s tools/$cli' auth login --account 'user name' 'a''b' '$token' ''"),
-        ] {
-            assert_eq!(
-                render_login_command(
-                    Path::new("/agent's tools/$cli"),
-                    ["auth", "login", "--account", "user name", "a'b", "$token", ""],
-                    windows
-                ),
-                expected
-            );
-        }
-        let mut spec = builtin_spec("cursor").unwrap();
-        spec.id = "custom".into();
-        spec.source = AgentSource::Registry { version: "1.4.5".into(), update: None };
-        spec.login_hint = "Sign in with the agent's own command line first.".into();
-        for method in [
-            json!({"type": "terminal"}),
-            json!({"type": "terminal", "args": ["login", null]}),
-            json!({"type": "agent", "args": ["login"]}),
-        ] {
-            assert_eq!(
-                spec.sign_in_message(&[method]),
-                "Cursor needs you to sign in. Sign in with the agent's own command line first."
-            );
-        }
-    }
-
-    #[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() {
@@ -640,15 +396,6 @@ mod tests {
        set_builtin_env(dir.path(), "not-a-builtin", env).unwrap_err();
    }

-    #[test]
-    fn acp_adapters_of_native_agents_are_unlisted_until_customized() {
-        let dir = tempfile::tempdir().unwrap();
-        let unlisted = |dir: &Path| load(Some(dir)).into_iter().filter(is_unlisted).map(|s| s.id).collect::<Vec<_>>();
-        assert_eq!(unlisted(dir.path()), ["claude-acp", "codex-acp"]);
-        set_builtin_env(dir.path(), "codex-acp", BTreeMap::from([("A".to_owned(), "1".to_owned())])).unwrap();
-        assert_eq!(unlisted(dir.path()), ["claude-acp"]);
-    }
-
    #[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();
@@ -2,7 +2,7 @@
 //! skills (`.claude/skills/<dir>/SKILL.md`) and custom commands (`.claude/commands/**/*.md`)
 //! of the working directory and every directory above it, then the user's `~/.claude`.

-use crate::{AgentCommand, AgentCommandSource};
+use crate::AgentCommand;
 use std::collections::HashSet;
 use std::path::Path;

@@ -36,14 +36,9 @@ pub(crate) fn discover(cwd: &Path, home: Option<&Path>) -> Vec<AgentCommand> {

 /// `first` (the agent's own list) plus the commands of `more` it lacks.
 pub(crate) fn merge(first: Vec<AgentCommand>, more: Vec<AgentCommand>) -> Vec<AgentCommand> {
+    let names: HashSet<String> = first.iter().map(|c| c.name.clone()).collect();
    let mut out = first;
-    for c in more {
-        if let Some(offered) = out.iter_mut().find(|offered| offered.name == c.name) {
-            offered.source = c.source;
-        } else {
-            out.push(c);
-        }
-    }
+    out.extend(more.into_iter().filter(|c| !names.contains(&c.name)));
    out
 }

@@ -66,7 +61,7 @@ fn skills(dir: &Path) -> Vec<AgentCommand> {
                return None;
            }
            let name = meta.get("name").filter(|n| !n.is_empty()).map(str::to_owned).or_else(|| file_name(&path))?;
-            Some(meta.command(name, &text, AgentCommandSource::Skill))
+            Some(meta.command(name, &text))
        })
        .collect();
    out.sort_by(|a, b| a.name.cmp(&b.name));
@@ -84,7 +79,7 @@ fn commands(dir: &Path, prefix: &str, depth: usize, out: &mut Vec<AgentCommand>)
        } else if let Some(stem) = name.strip_suffix(".md")
            && let Ok(text) = std::fs::read_to_string(&path)
        {
-            out.push(Frontmatter::parse(&text).command(format!("{prefix}{stem}"), &text, AgentCommandSource::Command));
+            out.push(Frontmatter::parse(&text).command(format!("{prefix}{stem}"), &text));
        }
    }
 }
@@ -152,7 +147,7 @@ impl Frontmatter {
    }

    /// `description`, else the body's first line.
-    fn command(&self, name: String, text: &str, source: AgentCommandSource) -> AgentCommand {
+    fn command(&self, name: String, text: &str) -> AgentCommand {
        let description = self.get("description").filter(|d| !d.is_empty()).map(str::to_owned).unwrap_or_else(|| {
            let body = text.get(self.body..).unwrap_or_default();
            body.lines()
@@ -163,7 +158,6 @@ impl Frontmatter {
        });
        AgentCommand {
            name,
-            source,
            description: truncate(&description),
            hint: self.get("argument-hint").filter(|h| !h.is_empty()).map(str::to_owned),
        }
@@ -200,20 +194,13 @@ mod tests {
    }

    fn cmd(name: &str, description: &str) -> AgentCommand {
-        AgentCommand {
-            name: name.into(),
-            description: description.into(),
-            hint: None,
-            source: AgentCommandSource::Command,
-        }
+        AgentCommand { name: name.into(), description: description.into(), hint: None }
    }

    #[test]
    fn project_and_user_skills_and_commands() {
        let tmp = tempfile::tempdir().unwrap();
-        // Home is an ancestor of the project, so the walk stops there instead of climbing
-        // past it into the real profile (a temp dir under the user's home holds its skills).
-        let home = tmp.path().to_path_buf();
+        let home = tmp.path().join("home");
        let repo = tmp.path().join("work").join("idea");
        let skills = repo.join(".claude/skills");
        write(
@@ -240,12 +227,6 @@ mod tests {
            ["issue-fix", "triage", "verify", "git:commit", "review", "parent", "lint", "brooks-review"]
        );
        let by = |n: &str| found.iter().find(|c| c.name == n).unwrap();
-        for name in ["issue-fix", "triage", "verify", "lint"] {
-            assert_eq!(by(name).source, AgentCommandSource::Skill);
-        }
-        for name in ["git:commit", "review", "parent", "brooks-review"] {
-            assert_eq!(by(name).source, AgentCommandSource::Command);
-        }
        assert_eq!(by("triage").description, "One pass over open issues and PRs");
        assert_eq!(by("issue-fix").description, "Fix an issue");
        assert_eq!(by("verify").description, "Build and drive the app");
@@ -281,14 +262,10 @@ mod tests {
    fn the_agents_entries_win() {
        let merged = merge(
            vec![cmd("triage", "from the agent"), cmd("compact", "Compact")],
-            vec![
-                AgentCommand { source: AgentCommandSource::Skill, ..cmd("triage", "from disk") },
-                cmd("verify", "Verify"),
-            ],
+            vec![cmd("triage", "from disk"), cmd("verify", "Verify")],
        );
        assert_eq!(names(&merged), ["triage", "compact", "verify"]);
        assert_eq!(merged[0].description, "from the agent");
-        assert_eq!(merged[0].source, AgentCommandSource::Skill);
    }

    #[test]
@@ -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));
@@ -116,7 +116,7 @@ pub(crate) fn changes(cwd: &Path, base: &str) -> IdeResult<Vec<AgentChange>> {
 /// Size and modification time of a file, `None` once it is gone.
 pub(crate) type Stamp = Option<(u64, u128)>;

-pub(crate) fn stamp(path: &Path) -> Stamp {
+fn stamp(path: &Path) -> Stamp {
    let meta = std::fs::metadata(path).ok()?;
    let modified = meta.modified().ok()?.duration_since(UNIX_EPOCH).ok()?.as_nanos();
    Some((meta.len(), modified))
@@ -132,77 +132,6 @@ pub(crate) fn without_untouched(changes: Vec<AgentChange>, before: &BTreeMap<Str
    changes.into_iter().filter(|c| before.get(&c.rel_path).is_none_or(|s| *s != stamp(&c.path))).collect()
 }

-/// Files larger than this that were changed before the task keep no copy: they can't be rolled back.
-const SAVED_MAX: u64 = 8 * 1024 * 1024;
-
-fn saved_name(rel: &str) -> String {
-    use std::hash::{DefaultHasher, Hash, Hasher};
-    let mut hash = DefaultHasher::new();
-    rel.hash(&mut hash);
-    format!("{:016x}", hash.finish())
-}
-
-/// Copies the files in `before` (already changed in the checkout at `cwd` when the task started)
-/// into `dir`, so rolling back the task's changes to them restores the user's own edits.
-/// Whether anything was saved.
-pub(crate) fn save_before(cwd: &Path, before: &BTreeMap<String, Stamp>, dir: &Path) -> IdeResult<bool> {
-    let Some(repo) = Repo::discover(cwd)? else { return Ok(false) };
-    let mut saved = false;
-    for (rel, stamp) in before {
-        let path = repo.root().join(rel);
-        if stamp.is_none() || !std::fs::metadata(&path).is_ok_and(|m| m.is_file() && m.len() <= SAVED_MAX) {
-            continue;
-        }
-        std::fs::create_dir_all(dir)?;
-        std::fs::copy(&path, dir.join(saved_name(rel)))?;
-        saved = true;
-    }
-    Ok(saved)
-}
-
-/// Rolls `change` back: to the copy saved when the task started when the file had changes
-/// then (`before`, `saved` holding the copies), otherwise to `base` (removed when `base`
-/// lacks it).
-pub(crate) fn restore(
-    cwd: &Path,
-    base: &str,
-    change: &AgentChange,
-    before: &BTreeMap<String, Stamp>,
-    saved: Option<&Path>,
-) -> IdeResult<()> {
-    let path = &change.path.0;
-    let content = match before.get(&change.rel_path) {
-        Some(None) => None,
-        Some(Some(_)) => {
-            let copy =
-                saved.map(|d| d.join(saved_name(&change.rel_path))).filter(|p| p.is_file()).ok_or_else(|| {
-                    IdeError::invalid(format!(
-                        "{} had changes of yours when the task started that weren't saved; roll it back in Git instead",
-                        change.rel_path
-                    ))
-                })?;
-            Some(std::fs::read(copy)?)
-        }
-        None => {
-            let repo = Repo::discover(cwd)?.ok_or_else(|| IdeError::invalid("not in a git repository"))?;
-            repo.file_bytes_at(path, Some(base))?
-        }
-    };
-    match content {
-        Some(bytes) => {
-            if let Some(parent) = path.parent() {
-                std::fs::create_dir_all(parent)?;
-            }
-            std::fs::write(path, bytes)?;
-        }
-        None => match std::fs::remove_file(path) {
-            Err(e) if e.kind() != std::io::ErrorKind::NotFound => return Err(e.into()),
-            _ => {}
-        },
-    }
-    Ok(())
-}
-
 pub(crate) fn file_at(cwd: &Path, path: &Path, rev: &str) -> IdeResult<Option<String>> {
    let Some(repo) = Repo::discover(cwd)? else { return Ok(None) };
    let encoding = match ide_vfs::load_text(path) {
@@ -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,10 +6,7 @@ edition.workspace = true
 license.workspace = true

 [dependencies]
-blake3.workspace = true
-chardetng.workspace = true
 dunce.workspace = true
-encoding_rs.workspace = true
 ide-core.workspace = true
 zip.workspace = true
 serde.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,38 +36,34 @@ 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"));
    }
    Ok(())
 }

-/// One planned step as fingerprinted: resolved program, args, cwd and env.
-type StepFingerprint = (PathBuf, Vec<String>, PathBuf, BTreeMap<String, String>);
-
-/// Environment, planned steps and input paths shared by every Maven build
-/// fingerprint: the filtered process environment plus the wrapper, settings
-/// and JDK files the planned invocation reads.
-struct Collected {
-    inputs: Vec<PathBuf>,
-    environment: BTreeMap<String, String>,
-    steps: Vec<StepFingerprint>,
-    inherited_hash: u64,
-}
-
-fn collect(
+/// `None` means an input cannot be resolved safely: build normally without reuse.
+/// All filesystem work belongs on the caller's blocking thread.
+pub fn launch_fingerprint(
    root: &Path,
-    projects: &[&maven::MavenProject],
-    plan: &BuildPlan,
+    model: &BuildModel,
+    module: &Path,
+    test: bool,
    local_repo: Option<PathBuf>,
-) -> IdeResult<Option<Collected>> {
-    let Some(mut inputs) = maven::launch_inputs(root, projects, local_repo) else { return Ok(None) };
+    cancel: &CancellationToken,
+) -> IdeResult<Option<LaunchFingerprint>> {
+    let Some(m) = &model.maven else { return Ok(None) };
+    let projects = maven_launch_projects(root, m, module, test);
+    if projects.is_empty() {
+        return Ok(None);
+    }
+    let Some(mut inputs) = maven::launch_inputs(root, &projects, local_repo) else { return Ok(None) };
+    let plan = launch_plan(root, model, module, test)?;
    let mut environment: BTreeMap<String, String> = std::env::vars()
        .map(|(key, value)| (key.to_ascii_uppercase(), value))
        .filter(|(key, _)| {
@@ -168,132 +133,23 @@ fn collect(
            Path::new(home).join(if cfg!(windows) { "bin/java.exe" } else { "bin/java" }),
        ]);
    }
-    let steps = plan
-        .steps
-        .iter()
-        .map(|s| (process::program_path(&s.program, &s.env), s.args.clone(), s.cwd.clone(), s.env.clone()))
-        .collect();
+    let steps: Vec<_> =
+        plan.steps.iter().map(|s| (process::program_path(&s.program, &s.env), &s.args, &s.cwd, &s.env)).collect();
    // Profiles and plugins can read arbitrary environment variables. Keep a signature
    // of the inherited environment without persisting unrelated credentials.
    let inherited: BTreeMap<_, _> = std::env::vars_os().collect();
    let mut inherited_hash = std::hash::DefaultHasher::new();
    inherited.hash(&mut inherited_hash);
-    Ok(Some(Collected { inputs, environment, steps, inherited_hash: inherited_hash.finish() }))
-}
-
-/// Scans every input, storing project inputs relative to the project.
-fn scan_all(
-    root: &Path,
-    inputs: Vec<PathBuf>,
-    cancel: &CancellationToken,
-) -> IdeResult<BTreeMap<PathBuf, Option<Stamp>>> {
+    let parameters =
+        serde_json::to_string(&(root, module, test, steps, environment, inherited_hash.finish(), projects))
+            .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.
-    Ok(files.into_iter().map(|(p, stamp)| (p.strip_prefix(root).unwrap_or(&p).to_path_buf(), stamp)).collect())
-}
-
-/// `None` means an input cannot be resolved safely: build normally without reuse.
-/// All filesystem work belongs on the caller's blocking thread.
-pub fn launch_fingerprint(
-    root: &Path,
-    model: &BuildModel,
-    module: &Path,
-    test: bool,
-    local_repo: Option<PathBuf>,
-    cancel: &CancellationToken,
-) -> IdeResult<Option<LaunchFingerprint>> {
-    let Some(m) = &model.maven else { return Ok(None) };
-    let projects = maven_launch_projects(root, m, module, test);
-    if projects.is_empty() {
-        return Ok(None);
-    }
-    let plan = launch_plan(root, model, module, test, BuildKind::Build)?;
-    let Some(collected) = collect(root, &projects, &plan, local_repo)? else { return Ok(None) };
-    let Collected { inputs, environment, steps, inherited_hash } = collected;
-    let parameters = serde_json::to_string(&(root, module, test, steps, environment, inherited_hash, projects))
-        .map_err(|e| IdeError::internal(e.to_string()))?;
-    Ok(Some(LaunchFingerprint { version: 2, parameters, files: scan_all(root, inputs, cancel)? }))
-}
-
-/// Inputs fingerprint of a menu build (`Build Project` / `Build Module`): the
-/// built modules' sources, resources and POM chain plus the exact planned
-/// steps, so an unchanged project skips Maven entirely (#2476). Only `Build`
-/// callers reuse it, never `Rebuild` or `Artifacts`; `None` disables reuse.
-/// All filesystem work belongs on the caller's blocking thread.
-pub fn menu_fingerprint(
-    root: &Path,
-    model: &BuildModel,
-    file: Option<&Path>,
-    cancel: &CancellationToken,
-) -> IdeResult<Option<LaunchFingerprint>> {
-    let plan = plan(root, model, BuildKind::Build, file, None)?;
-    if plan.system != BuildSystem::Maven {
-        return Ok(None);
-    }
-    let Some(m) = &model.maven else { return Ok(None) };
-    let projects: Vec<&maven::MavenProject> = match file {
-        Some(file) => {
-            // The innermost linked project owning the file, as in single-file compilation.
-            let rel = rel_str(root, file);
-            let module = m
-                .projects
-                .iter()
-                .filter(|p| rel == p.dir || rel.starts_with(&format!("{}/", p.dir)) || p.dir.is_empty())
-                .max_by_key(|p| p.dir.len());
-            match module {
-                Some(project) if project.packaging != "pom" => {
-                    maven_launch_projects(root, m, &subdir(root, &project.dir), true)
-                }
-                _ => return Ok(None),
-            }
-        }
-        // A project build walks every linked project.
-        None => m.projects.iter().collect(),
-    };
-    if projects.is_empty() {
-        return Ok(None);
-    }
-    let Some(collected) = collect(root, &projects, &plan, None)? else { return Ok(None) };
-    let Collected { inputs, environment, steps, inherited_hash } = collected;
-    let scope = file.map(|f| rel_str(root, f));
-    let parameters = serde_json::to_string(&("menu-build", scope, steps, environment, inherited_hash))
-        .map_err(|e| IdeError::internal(e.to_string()))?;
-    Ok(Some(LaunchFingerprint { version: 2, parameters, files: scan_all(root, inputs, cancel)? }))
-}
-
-impl LaunchFingerprint {
-    /// Folders (relative to the project) of the Maven projects whose POM is an input.
-    pub(super) fn project_dirs(&self) -> impl Iterator<Item = &Path> {
-        self.files
-            .keys()
-            .filter(|p| p.is_relative() && p.file_name().is_some_and(|n| n == "pom.xml"))
-            .map(|pom| pom.parent().unwrap_or(Path::new("")))
-    }
-
-    /// Relative paths whose content changed while `(length, mtime)` stayed the same
-    /// compared to `previous` (timestamp-preserving external edits, coarse-granularity
-    /// filesystems). Timestamp-incremental builders (Maven, the Kotlin plugin) would
-    /// skip these sources as "unchanged", so the rebuild the fingerprint triggers
-    /// compiles nothing and the stale outputs get re-recorded as fresh. Callers
-    /// re-stamp the returned paths before building. Inputs without a content hash
-    /// (directories, files outside the project) are never reported.
-    pub fn mtime_preserved_edits(&self, current: &Self) -> Vec<PathBuf> {
-        let mut edits = Vec::new();
-        for (path, current_stamp) in &current.files {
-            let Some(current_stamp) = current_stamp else { continue };
-            let Some(previous_stamp) = self.files.get(path).and_then(|stamp| stamp.as_ref()) else { continue };
-            let (len, mtime, Some(current_hash)) = current_stamp else { continue };
-            let (prev_len, prev_mtime, Some(prev_hash)) = previous_stamp else { continue };
-            if current_hash != prev_hash && len == prev_len && mtime == prev_mtime {
-                edits.push(path.clone());
-            }
-        }
-        edits.sort();
-        edits
-    }
+    let files = files.into_iter().map(|(p, stamp)| (p.strip_prefix(root).unwrap_or(&p).to_path_buf(), stamp)).collect();
+    Ok(Some(LaunchFingerprint { version: 1, parameters, files }))
 }

 #[cfg(test)]
@@ -375,79 +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 mtime_preserved_edits_only_reports_lying_timestamps() {
-        fn stamp(len: u64, hash: &str) -> Option<Stamp> {
-            Some((len, SystemTime::UNIX_EPOCH + std::time::Duration::from_secs(42), Some(hash.into())))
-        }
-        fn prints(
-            previous: BTreeMap<PathBuf, Option<Stamp>>,
-            current: BTreeMap<PathBuf, Option<Stamp>>,
-        ) -> Vec<PathBuf> {
-            let previous = LaunchFingerprint { version: 2, parameters: String::new(), files: previous };
-            let current = LaunchFingerprint { version: 2, parameters: String::new(), files: current };
-            previous.mtime_preserved_edits(&current)
-        }
-        // Same length and mtime, different content: the builder would skip it.
-        assert_eq!(
-            prints([("a.java".into(), stamp(5, "old"))].into(), [("a.java".into(), stamp(5, "new"))].into()),
-            vec![PathBuf::from("a.java")]
-        );
-        // A normal edit bumps the mtime: the builder already sees it.
-        let mut touched = stamp(5, "new").unwrap();
-        touched.1 += std::time::Duration::from_secs(1);
-        assert!(
-            prints([("a.java".into(), stamp(5, "old"))].into(), [("a.java".into(), Some(touched))].into()).is_empty()
-        );
-        // Added, deleted, and hash-less inputs (directories, files outside the
-        // project) carry no comparable content: never reported.
-        assert!(
-            prints(
-                [("gone.java".into(), stamp(5, "old")), ("dir".into(), None)].into(),
-                [("new.java".into(), stamp(5, "new")), ("dir".into(), None)].into()
-            )
-            .is_empty()
-        );
-    }
-
-    #[test]
-    fn lying_source_is_found_against_a_real_fingerprint() {
-        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).unwrap();
-        let mtime = fs::metadata(&source).unwrap().modified().unwrap();
-        // Same 5-byte length, different content, preserved mtime.
-        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).unwrap();
-        assert_eq!(before.mtime_preserved_edits(&after), [PathBuf::from("lib/src/main/kotlin/Channel.kt")]);
-        // A normal edit (mtime advances) needs no repair.
-        write(root, "lib/src/main/kotlin/Channel.kt", "valve!");
-        let normal = fingerprint(root, &model).unwrap();
-        assert!(before.mtime_preserved_edits(&normal).is_empty());
-    }
-
    #[test]
    fn profile_options_jdk_goal_and_wrapper_invalidate_without_using_class_outputs() {
        let dir = tempfile::tempdir().unwrap();
@@ -1,253 +0,0 @@
-//! Resources a Gradle build changes while copying them (filters, `expand`, renames, extra
-//! sources). The Java language server copies them as they are into Buildship's
-//! `bin/<source set>` folders, which launches run from; IntelliJ IDEA runs Gradle's copy.
-//! Before a launch, Gradle processes them and its output replaces those plain copies, so
-//! each resource is on the classpath once, as the build produces it.
-use super::{BuildPlan, BuildStep, BuildSystem, Format, run, subdir};
-use crate::BuildModel;
-use crate::gradle::{self, GradleModel, ReportedProject};
-use ide_core::{CancellationToken, IdeError, IdeResult, Severity};
-use std::fs;
-use std::path::{Path, PathBuf};
-
-/// A source set whose resources Gradle processes, with the folder the launch reads them from.
-#[derive(Debug, PartialEq)]
-struct Target {
-    /// Task path from the root build (`:app:processResources`).
-    task: String,
-    /// Where the task writes the resources.
-    output: PathBuf,
-    /// The Java language server's output folder of the source set, on the launch classpath.
-    jdtls: PathBuf,
-}
-
-fn targets(reported: &[ReportedProject], class_paths: &[String]) -> Vec<Target> {
-    // buildSrc is built before the build, never addressable as `:buildSrc:<task>`.
-    let addressable = |p: &&ReportedProject| !p.build.as_deref().is_some_and(|b| b.ends_with(":buildSrc"));
-    let sets: Vec<_> = reported
-        .iter()
-        .filter(addressable)
-        .flat_map(|p| p.source_sets.iter().filter_map(move |s| Some((p, s, s.processed.as_ref()?))))
-        .collect();
-    if sets.is_empty() {
-        return Vec::new();
-    }
-    // Canonical, as Gradle reports its folders: jdtls may spell them differently.
-    let entries: Vec<PathBuf> = class_paths.iter().filter_map(|p| dunce::canonicalize(p).ok()).collect();
-    sets.into_iter()
-        .filter_map(|(p, set, resources)| {
-            // Buildship's output folder of the source set.
-            let jdtls = dunce::canonicalize(Path::new(&p.dir).join("bin").join(&set.name)).ok()?;
-            let project = if p.path == ":" { "" } else { p.path.as_str() };
-            entries.contains(&jdtls).then(|| Target {
-                task: format!("{project}:{}", resources.task),
-                output: PathBuf::from(&resources.dir),
-                jdtls,
-            })
-        })
-        .collect()
-}
-
-/// Before a JVM launch from the Java language server's output folders on `class_paths`:
-/// runs the Gradle tasks that process resources of those folders' source sets (see the
-/// module docs) and copies their output over the plain copies. `cache_dir` holds the
-/// linked builds' last syncs. Returns the tasks run, none for builds that copy their
-/// resources as they are.
-pub fn process_launch_resources(
-    root: &Path,
-    model: &BuildModel,
-    cache_dir: &Path,
-    class_paths: &[String],
-    cancel: &CancellationToken,
-) -> IdeResult<Vec<String>> {
-    // A composite also reports the builds it includes: the deepest build owning a folder runs its task.
-    let mut builds: Vec<&GradleModel> = model.gradle.iter().collect();
-    builds.sort_by_key(|g| std::cmp::Reverse(subdir(root, &g.dir).components().count()));
-    let mut done: Vec<PathBuf> = Vec::new();
-    let mut tasks = Vec::new();
-    for g in builds {
-        let reported = crate::sync::reported_gradle_projects(&gradle::cache_dir(cache_dir, &g.dir));
-        let targets: Vec<Target> =
-            targets(&reported, class_paths).into_iter().filter(|t| !done.contains(&t.jdtls)).collect();
-        if targets.is_empty() {
-            continue;
-        }
-        let mut step = BuildStep::new(&g.command, &["--console=plain"], &subdir(root, &g.dir), Format::Gradle);
-        step.args.extend(targets.iter().map(|t| t.task.clone()));
-        step.env = g.env.clone();
-        let plan = BuildPlan { system: BuildSystem::Gradle, title: "Process resources".into(), steps: vec![step] };
-        let result = run(root, &plan, cancel, &|_| {})?;
-        if !result.success {
-            let errors: Vec<&str> = result
-                .messages
-                .iter()
-                .filter(|m| m.severity == Severity::Error)
-                .take(5)
-                .map(|m| m.text.as_str())
-                .collect();
-            return Err(IdeError::internal(errors.join("\n")));
-        }
-        for t in targets {
-            if cancel.is_cancelled() {
-                return Err(IdeError::cancelled());
-            }
-            overlay(&t.output, &t.output, &t.jdtls)?;
-            done.push(t.jdtls);
-            tasks.push(t.task);
-        }
-    }
-    Ok(tasks)
-}
-
-/// Copies the files under `dir` to the same place under `to` (relative to `base`) where
-/// they differ, so unchanged resources are not rewritten on every launch.
-fn overlay(base: &Path, dir: &Path, to: &Path) -> IdeResult<()> {
-    let entries = match fs::read_dir(dir) {
-        // No resources: the task had nothing to copy.
-        Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(()),
-        entries => entries?,
-    };
-    for entry in entries {
-        let entry = entry?;
-        let path = entry.path();
-        let kind = entry.file_type()?;
-        if kind.is_dir() {
-            overlay(base, &path, to)?;
-        } else if kind.is_file() {
-            let dest = to.join(path.strip_prefix(base).map_err(|e| IdeError::internal(e.to_string()))?);
-            if !same_content(&path, &dest) {
-                if let Some(parent) = dest.parent() {
-                    fs::create_dir_all(parent)?;
-                }
-                fs::copy(&path, &dest)?;
-            }
-        }
-    }
-    Ok(())
-}
-
-fn same_content(a: &Path, b: &Path) -> bool {
-    match (fs::metadata(a), fs::metadata(b)) {
-        (Ok(m), Ok(n)) if m.len() == n.len() => matches!((fs::read(a), fs::read(b)), (Ok(x), Ok(y)) if x == y),
-        _ => false,
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::gradle::{ProcessedResources, ReportedSourceSet};
-
-    fn write(path: &Path, text: &str) {
-        fs::create_dir_all(path.parent().unwrap()).unwrap();
-        fs::write(path, text).unwrap();
-    }
-
-    fn set(name: &str, processed: Option<&Path>) -> ReportedSourceSet {
-        ReportedSourceSet {
-            name: name.into(),
-            test: name == "test",
-            processed: processed.map(|dir| ProcessedResources {
-                task: if name == "main" { "processResources".into() } else { "processTestResources".into() },
-                dir: dir.to_string_lossy().into_owned(),
-            }),
-            ..Default::default()
-        }
-    }
-
-    fn project(path: &str, dir: &Path, sets: Vec<ReportedSourceSet>) -> ReportedProject {
-        ReportedProject {
-            path: path.into(),
-            dir: dir.to_string_lossy().into_owned(),
-            source_sets: sets,
-            ..Default::default()
-        }
-    }
-
-    /// Only processed source sets whose jdtls output is on the classpath: the launched
-    /// module, upstream modules of the build, tests only for a test classpath; never buildSrc.
-    #[test]
-    fn targets_are_processed_sets_on_the_classpath() {
-        let tmp = tempfile::tempdir().unwrap();
-        let root = dunce::canonicalize(tmp.path()).unwrap();
-        let (app, lib, plain, src) = (root.join("app"), root.join("lib"), root.join("plain"), root.join("buildSrc"));
-        for dir in [&root, &app, &lib, &plain, &src] {
-            for set in ["main", "test"] {
-                fs::create_dir_all(dir.join("bin").join(set)).unwrap();
-            }
-        }
-        let out = |dir: &Path, set: &str| dir.join("build/resources").join(set);
-        let mut build_src = project(":buildSrc", &src, vec![set("main", Some(&out(&src, "main")))]);
-        build_src.build = Some(":buildSrc".into());
-        let reported = [
-            project(":", &root, vec![set("main", Some(&out(&root, "main")))]),
-            project(":app", &app, vec![set("main", Some(&out(&app, "main"))), set("test", Some(&out(&app, "test")))]),
-            project(":lib", &lib, vec![set("main", Some(&out(&lib, "main")))]),
-            project(":plain", &plain, vec![set("main", None)]),
-            build_src,
-        ];
-        let entry = |dir: &Path, set: &str| dir.join("bin").join(set).to_string_lossy().into_owned();
-        let runtime = [
-            entry(&app, "main"),
-            // Spelled differently from Gradle's canonical folders.
-            format!("{}/", entry(&lib, "main")),
-            entry(&plain, "main"),
-            entry(&src, "main"),
-            "/m2/spring-core.jar".into(),
-        ];
-        let tasks = |cp: &[String]| targets(&reported, cp).into_iter().map(|t| t.task).collect::<Vec<_>>();
-        assert_eq!(tasks(&runtime), [":app:processResources", ":lib:processResources"]);
-        let mut test = runtime.to_vec();
-        test.insert(0, entry(&app, "test"));
-        assert_eq!(tasks(&test), [":app:processResources", ":app:processTestResources", ":lib:processResources"]);
-        assert_eq!(tasks(&[entry(&root, "main")]), [":processResources"], "the root project");
-        let app_targets = targets(&reported, &runtime);
-        let t = &app_targets[0];
-        assert_eq!(
-            (t.output.as_path(), t.jdtls.as_path()),
-            (out(&app, "main").as_path(), app.join("bin/main").as_path())
-        );
-
-        let unprocessed = [project(":app", &app, vec![set("main", None)])];
-        assert!(targets(&unprocessed, &runtime).is_empty());
-    }
-
-    /// The processed copy replaces jdtls's plain one (the reported `@version@` case), new
-    /// files are added, identical ones are left alone and files Gradle doesn't produce stay.
-    #[test]
-    fn overlay_replaces_plain_copies_with_gradle_output() {
-        let tmp = tempfile::tempdir().unwrap();
-        let (output, jdtls) = (tmp.path().join("build/resources/main"), tmp.path().join("bin/main"));
-        write(&output.join("application.yaml"), "spring:\n  application:\n    version: 0.0.1\n");
-        write(&output.join("static/extra.txt"), "from an extra source");
-        write(&output.join("migrations/V1__init.sql"), "create table t (id int);");
-        write(&jdtls.join("application.yaml"), "spring:\n  application:\n    version: @version@\n");
-        write(&jdtls.join("migrations/V1__init.sql"), "create table t (id int);");
-        write(&jdtls.join("com/example/App.class"), "bytecode");
-        let unchanged = fs::metadata(jdtls.join("migrations/V1__init.sql")).unwrap().modified().unwrap();
-        std::thread::sleep(std::time::Duration::from_millis(20));
-
-        overlay(&output, &output, &jdtls).unwrap();
-        let read = |rel: &str| fs::read_to_string(jdtls.join(rel)).unwrap();
-        assert_eq!(read("application.yaml"), "spring:\n  application:\n    version: 0.0.1\n");
-        assert_eq!(read("static/extra.txt"), "from an extra source");
-        assert_eq!(read("com/example/App.class"), "bytecode");
-        let modified = fs::metadata(jdtls.join("migrations/V1__init.sql")).unwrap().modified().unwrap();
-        assert_eq!(modified, unchanged, "identical files are not rewritten");
-
-        overlay(&tmp.path().join("missing"), &tmp.path().join("missing"), &jdtls).unwrap();
-    }
-
-    #[test]
-    fn builds_without_processed_resources_run_nothing() {
-        let tmp = tempfile::tempdir().unwrap();
-        // Running this command would fail the call.
-        let missing = tmp.path().join("missing-gradle").to_string_lossy().into_owned();
-        let model =
-            BuildModel { gradle: vec![GradleModel { command: missing, ..Default::default() }], ..Default::default() };
-        let class_paths = [tmp.path().join("bin/main").to_string_lossy().into_owned()];
-        let tasks =
-            process_launch_resources(tmp.path(), &model, tmp.path(), &class_paths, &CancellationToken::new()).unwrap();
-        assert!(tasks.is_empty());
-    }
-}
@@ -4,17 +4,9 @@
 //! for the Build tool window, the Problems view and the editor.

 mod fingerprint;
-mod launch_resources;
 mod parse;
-mod single;
-mod up_to_date;

-pub use fingerprint::{LaunchFingerprint, launch_fingerprint, menu_fingerprint};
-pub use launch_resources::process_launch_resources;
-pub use single::{
-    SingleFileTarget, compile_file_plan, find_javac, javac_step, single_file_classpath, single_file_target,
-};
-pub use up_to_date::{menu_up_to_date, record_menu_build};
+pub use fingerprint::{LaunchFingerprint, launch_fingerprint};

 use crate::process::{self, Stream};
 use crate::{BuildModel, maven};
@@ -75,11 +67,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());
@@ -160,13 +147,11 @@ 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)
@@ -177,13 +162,16 @@ fn detect_dir(dir: &Path, model: &BuildModel, root: &Path) -> Option<BuildSystem
    }
 }

-/// 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).
@@ -204,14 +192,7 @@ pub fn plan(
    let project_name = root.file_name().map_or_else(|| "project".to_owned(), |n| n.to_string_lossy().into_owned());
    let module_dir = match file {
        Some(f) => {
-            let 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())
@@ -221,7 +202,7 @@ pub fn plan(
    let dir = module_dir.clone().unwrap_or_else(|| root.to_path_buf());
    // A folder of sibling projects has no build file itself; its Maven projects are built one by one.
    let system = detect_dir(&dir, model, root)
-        .or((!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")
@@ -240,19 +221,14 @@ 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,
@@ -271,12 +247,7 @@ pub(super) fn maven_steps(
        return Err(IdeError::not_found("no Maven project found"));
    }
    let step = |p: &maven::MavenProject, extra: &[String]| {
-        let mut s = BuildStep::new(
-            &p.command,
-            &["-B", "-Dstyle.color=never", maven::LOCAL_REPO_TRACKING_ARG],
-            &subdir(root, &p.dir),
-            Format::Maven,
-        );
+        let mut s = BuildStep::new(&p.command, &["-B", "-Dstyle.color=never"], &subdir(root, &p.dir), Format::Maven);
        s.args.extend(p.options.iter().cloned());
        s.args.extend(extra.iter().cloned());
        s.args.extend(goals.iter().map(|g| (*g).to_owned()));
@@ -299,16 +270,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);
@@ -327,7 +296,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> {
@@ -392,33 +361,7 @@ fn cmake_steps(dir: &Path, kind: BuildKind, profile: Option<&CMakeProfile>) -> V
    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"];
@@ -432,7 +375,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 {
@@ -785,7 +739,13 @@ pub fn launch_has_non_java_sources(root: &Path, model: &BuildModel, module: &Pat
    has_non_java_sources(module)
 }

-fn launch_plan(root: &Path, model: &BuildModel, module: &Path, test: bool, kind: BuildKind) -> IdeResult<BuildPlan> {
+fn launch_plan(root: &Path, model: &BuildModel, module: &Path, test: bool) -> IdeResult<BuildPlan> {
+    let kind = if model.maven.as_ref().is_some_and(|m| m.projects.iter().any(|p| subdir(root, &p.dir) == module)) {
+        // JDT may have left newer error stubs in Maven's output directories.
+        BuildKind::Rebuild
+    } else {
+        BuildKind::Build
+    };
    let mut plan = plan(root, model, kind, Some(module), None)?;
    if plan.system == BuildSystem::Maven && !test {
        for step in &mut plan.steps {
@@ -797,12 +757,6 @@ fn launch_plan(root: &Path, model: &BuildModel, module: &Path, test: bool, kind:
    Ok(plan)
 }

-#[derive(Debug)]
-pub struct LaunchBuild {
-    pub class_dirs: Vec<PathBuf>,
-    pub failure: Option<String>,
-}
-
 /// Compiles the module at `module` with its build system before a JVM launch and
 /// returns the class directories it wrote, to put ahead of the jdtls classpath.
 pub fn build_for_launch(
@@ -810,12 +764,11 @@ pub fn build_for_launch(
    model: &BuildModel,
    module: &Path,
    test: bool,
-    kind: BuildKind,
    cancel: &CancellationToken,
-) -> IdeResult<LaunchBuild> {
-    let plan = launch_plan(root, model, module, test, kind)?;
+) -> IdeResult<Vec<PathBuf>> {
+    let plan = launch_plan(root, model, module, test)?;
    let result = run(root, &plan, cancel, &|_| {})?;
-    let failure = if !result.success {
+    if !result.success {
        let errors: Vec<String> = result
            .messages
            .iter()
@@ -826,21 +779,17 @@ pub fn build_for_launch(
                _ => m.text.clone(),
            })
            .collect();
-        Some(format!("Build failed:\n{}", errors.join("\n")))
-    } else {
-        None
-    };
-    let class_dirs = if plan.system == BuildSystem::Maven
+        return Err(IdeError::internal(format!("Build failed:\n{}", errors.join("\n"))));
+    }
+    if plan.system == BuildSystem::Maven
        && let Some(m) = &model.maven
    {
-        maven_launch_projects(root, m, module, test)
+        return Ok(maven_launch_projects(root, m, module, test)
            .iter()
            .flat_map(|p| launch_class_dirs(plan.system, &subdir(root, &p.dir), test && subdir(root, &p.dir) == module))
-            .collect()
-    } else {
-        launch_class_dirs(plan.system, module, test)
-    };
-    Ok(LaunchBuild { class_dirs, failure })
+            .collect());
+    }
+    Ok(launch_class_dirs(plan.system, module, test))
 }

 fn launch_class_dirs(system: BuildSystem, module: &Path, test: bool) -> Vec<PathBuf> {
@@ -862,153 +811,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
@@ -1057,21 +859,9 @@ mod tests {
        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", maven::LOCAL_REPO_TRACKING_ARG, "test-compile"]);
+        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();
-        assert_eq!(
-            p.steps[0].args,
-            [
-                "-B",
-                "-Dstyle.color=never",
-                maven::LOCAL_REPO_TRACKING_ARG,
-                "-pl",
-                "core",
-                "-am",
-                "clean",
-                "test-compile"
-            ]
-        );
+        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'");

@@ -1339,42 +1129,14 @@ mod tests {
        write(root, "app/pom.xml", "<project/>");
        let model = reactor_model();
        for (test, goal) in [(false, "compile"), (true, "test-compile")] {
-            // A normal launch is incremental: no `clean` (IDEA's Make, not Rebuild).
-            let plan = launch_plan(root, &model, &root.join("app"), test, BuildKind::Build).unwrap();
+            let plan = launch_plan(root, &model, &root.join("app"), test).unwrap();
            let step = &plan.steps[0];
            assert_eq!(step.cwd, root);
            assert_eq!(step.program, "mvnw");
            assert_eq!(step.env["JAVA_HOME"], "/jdk");
            assert_eq!(
                step.args,
-                [
-                    "-B",
-                    "-Dstyle.color=never",
-                    maven::LOCAL_REPO_TRACKING_ARG,
-                    "-s",
-                    "settings.xml",
-                    "-pl",
-                    "app",
-                    "-am",
-                    goal
-                ]
-            );
-            // Rebuild cleans first, as IDEA's Rebuild does.
-            let plan = launch_plan(root, &model, &root.join("app"), test, BuildKind::Rebuild).unwrap();
-            assert_eq!(
-                plan.steps[0].args,
-                [
-                    "-B",
-                    "-Dstyle.color=never",
-                    maven::LOCAL_REPO_TRACKING_ARG,
-                    "-s",
-                    "settings.xml",
-                    "-pl",
-                    "app",
-                    "-am",
-                    "clean",
-                    goal
-                ]
+                ["-B", "-Dstyle.color=never", "-s", "settings.xml", "-pl", "app", "-am", "clean", goal]
            );
        }
    }
@@ -1395,10 +1157,9 @@ mod tests {
        std::fs::set_permissions(&wrapper, std::fs::Permissions::from_mode(0o755)).unwrap();
        let mut model = reactor_model();
        model.maven.as_mut().unwrap().projects[0].command = wrapper.to_string_lossy().into_owned();
-        let dirs = build_for_launch(root, &model, &root.join("app"), true, BuildKind::Build, &CancellationToken::new())
-            .unwrap();
+        let dirs = build_for_launch(root, &model, &root.join("app"), true, &CancellationToken::new()).unwrap();
        assert_eq!(
-            dirs.class_dirs,
+            dirs,
            ["app/target/test-classes", "app/target/classes", "middle/target/classes", "lib/target/classes"]
                .map(|p| root.join(p))
        );
@@ -1407,16 +1168,12 @@ mod tests {
            "mvnw",
            "#!/bin/sh\necho '[ERROR] Kotlin compilation failed: unresolved reference broken' >&2\nexit 1\n",
        );
-        let error =
-            build_for_launch(root, &model, &root.join("app"), false, BuildKind::Build, &CancellationToken::new())
-                .unwrap()
-                .failure
-                .unwrap();
-        assert!(error.contains("Kotlin compilation failed"), "{error}");
+        let error = build_for_launch(root, &model, &root.join("app"), false, &CancellationToken::new()).unwrap_err();
+        assert!(error.message.contains("Kotlin compilation failed"), "{}", error.message);
        let cancel = CancellationToken::new();
        cancel.cancel();
        assert_eq!(
-            build_for_launch(root, &model, &root.join("app"), false, BuildKind::Build, &cancel).unwrap_err().kind,
+            build_for_launch(root, &model, &root.join("app"), false, &cancel).unwrap_err().kind,
            ide_core::error::ErrorKind::Cancelled
        );
    }
@@ -7,7 +7,6 @@
 //! [`super::resolve`] turns them into IDE coordinates.

 use ide_core::Severity;
-pub(crate) use ide_core::output_encoding::strip_ansi;
 use serde_json::Value;

 /// Output dialect of a build step.
@@ -99,6 +98,32 @@ pub(crate) struct OutputParser {
    pending: Option<Pending>,
 }

+/// Removes ANSI escape sequences (colour, cursor movement).
+pub(crate) fn strip_ansi(s: &str) -> String {
+    if !s.contains('\u{1b}') {
+        return s.to_owned();
+    }
+    let mut out = String::with_capacity(s.len());
+    let mut chars = s.chars().peekable();
+    while let Some(c) = chars.next() {
+        if c != '\u{1b}' {
+            out.push(c);
+            continue;
+        }
+        if chars.peek() == Some(&'[') {
+            chars.next();
+            for c in chars.by_ref() {
+                if c.is_ascii_alphabetic() || c == '~' {
+                    break;
+                }
+            }
+        } else {
+            chars.next();
+        }
+    }
+    out
+}
+
 fn num(s: &str) -> Option<u32> {
    s.trim().parse().ok().filter(|n| *n > 0)
 }
@@ -1,331 +0,0 @@
-//! Single-file Java compilation with `javac` for the Compile File action (#2476).
-//!
-//! A module build (`-pl … -am`) still walks every upstream module, and packaging
-//! walks the whole reactor; compiling one file only needs that file's module
-//! outputs plus its dependency classpath, which is much faster to assemble.
-use super::*;
-use std::fs;
-use std::process::Command as ProcCommand;
-
-/// Output file of the `dependency:build-classpath` probe, relative to each module.
-const CP_FILE: &str = "target/ide-compile-cp.txt";
-
-/// A `.java` source and the module build that compiles it.
-pub struct SingleFileTarget {
-    /// Absolute module directory.
-    pub module: PathBuf,
-    /// The source is under `src/test`: compile to test classes with the test classpath.
-    pub test: bool,
-    /// Absolute `target/classes` (or `target/test-classes`).
-    pub out_dir: PathBuf,
-    /// Reactor root building the module (owns the Maven command and options).
-    pub top: maven::MavenProject,
-    /// `-pl` value of the module relative to the reactor root; empty when the
-    /// module is the root itself.
-    pub pl: String,
-    /// `maven.compiler.release` (or equivalent) of the module's project.
-    pub java_version: Option<u32>,
-}
-
-/// Locates the linked Maven module owning a `.java` source file.
-pub fn single_file_target(root: &Path, model: &BuildModel, file: &Path) -> IdeResult<SingleFileTarget> {
-    if file.extension().is_none_or(|ext| ext != "java") {
-        return Err(IdeError::invalid("only Java sources can be compiled as a single file"));
-    }
-    if !file.is_file() {
-        return Err(IdeError::not_found("no Java source found for single-file compilation"));
-    }
-    let Some(m) = &model.maven else {
-        return Err(IdeError::not_found("no linked Maven project found for module"));
-    };
-    // The innermost project whose directory contains the file owns it; the
-    // aggregator root (`""`) is a prefix of everything, so take the longest match.
-    let rel = rel_str(root, file);
-    let project = m
-        .projects
-        .iter()
-        .filter(|p| rel == p.dir || rel.starts_with(&format!("{}/", p.dir)) || p.dir.is_empty())
-        .max_by_key(|p| p.dir.len())
-        .ok_or_else(|| IdeError::not_found("no linked Maven project found for module"))?;
-    if project.packaging == "pom" {
-        // An aggregator owns no sources itself: a file that only matches it
-        // belongs to no linked module.
-        return Err(IdeError::not_found("no linked Maven project found for module"));
-    }
-    let module = subdir(root, &project.dir);
-    let top = maven_reactor(m, &project.dir)
-        .ok_or_else(|| IdeError::not_found("no linked Maven project found for module"))?;
-    let top_dir = subdir(root, &top.dir);
-    let pl = module.strip_prefix(&top_dir).map(|r| r.to_string_lossy().replace('\\', "/")).unwrap_or_default();
-    // Test sources see the test classpath and compile into test classes.
-    let parts: Vec<&str> = rel.split('/').collect();
-    let test = parts.windows(2).any(|w| w == ["src", "test"]);
-    let out_dir = module.join("target").join(if test { "test-classes" } else { "classes" });
-    Ok(SingleFileTarget { module, test, out_dir, top: top.clone(), pl, java_version: project.java_version })
-}
-
-/// `javac` for the module: its `JAVA_HOME`, else `PATH`.
-pub fn find_javac(env: &BTreeMap<String, String>) -> String {
-    let home = env.get("JAVA_HOME").map(Path::new);
-    let exe = if cfg!(windows) { "javac.exe" } else { "javac" };
-    if let Some(javac) = home.map(|h| h.join("bin").join(exe)).filter(|p| p.is_file()) {
-        return javac.to_string_lossy().into_owned();
-    }
-    exe.to_owned()
-}
-
-/// Dependency classpath of the module: existing reactor class directories plus
-/// `mvn dependency:build-classpath` (which resolves without compiling anything,
-/// so `-am` stays cheap). Entries are platform-separated (`;` on Windows).
-pub fn single_file_classpath(root: &Path, model: &BuildModel, target: &SingleFileTarget) -> IdeResult<String> {
-    let mut entries: Vec<String> = Vec::new();
-    // The module's own classes first: the file almost always uses classes next to it.
-    let own: &[&str] = if target.test { &["target/test-classes", "target/classes"] } else { &["target/classes"] };
-    for out in own {
-        let path = target.module.join(out);
-        if path.is_dir() {
-            entries.push(path.to_string_lossy().into_owned());
-        }
-    }
-    if let Some(m) = &model.maven {
-        // Upstream reactor modules first: their freshly built classes shadow
-        // installed snapshots of the same artifacts.
-        for project in maven_launch_projects(root, m, &target.module, target.test) {
-            let dir = subdir(root, &project.dir);
-            if dir == target.module {
-                continue;
-            }
-            for classes in ["target/classes", "target/test-classes"] {
-                let path = dir.join(classes);
-                if path.is_dir() {
-                    entries.push(path.to_string_lossy().into_owned());
-                }
-            }
-        }
-    }
-    let probe = CP_FILE;
-    let mut args = vec!["-B", "-Dstyle.color=never", maven::LOCAL_REPO_TRACKING_ARG];
-    args.extend(target.top.options.iter().map(String::as_str));
-    if !target.pl.is_empty() {
-        args.extend(["-pl", target.pl.as_str(), "-am"]);
-    }
-    let output_arg = format!("-Dmdep.outputFile={probe}");
-    args.extend(["dependency:build-classpath", output_arg.as_str(), "-Dmdep.includeScope=test", "-q"]);
-    let top_dir = subdir(root, &target.top.dir);
-    let status = ProcCommand::new(&target.top.command)
-        .args(&args)
-        .envs(&target.top.env)
-        .current_dir(&top_dir)
-        .output()
-        .map_err(|e| IdeError::internal(format!("cannot resolve the compile classpath: {e}")))?;
-    if !status.status.success() {
-        let stderr = String::from_utf8_lossy(&status.stderr);
-        let tail: Vec<&str> = stderr.lines().filter(|l| !l.trim().is_empty()).collect();
-        let tail = tail.iter().rev().take(5).rev().cloned().collect::<Vec<_>>().join("\n");
-        return Err(IdeError::internal(format!("cannot resolve the compile classpath:\n{tail}")));
-    }
-    // With `-am` every visited module writes its own file; only this module's counts.
-    let cp_file = target.module.join(probe);
-    let content = fs::read_to_string(&cp_file).map_err(|e| {
-        IdeError::internal(format!("cannot resolve the compile classpath: {} ({e})", cp_file.display()))
-    })?;
-    let separator = if cfg!(windows) { ';' } else { ':' };
-    entries.extend(content.split([separator, '\n', '\r']).map(str::trim).filter(|e| !e.is_empty()).map(str::to_owned));
-    entries.dedup();
-    Ok(entries.join(&separator.to_string()))
-}
-
-/// The `javac` step compiling `file` into `target`'s output directory.
-pub fn javac_step(target: &SingleFileTarget, file: &Path, classpath: &str, javac: &str) -> IdeResult<BuildStep> {
-    fs::create_dir_all(&target.out_dir)
-        .map_err(|e| IdeError::internal(format!("cannot create {} ({e})", target.out_dir.display())))?;
-    let mut step = BuildStep::new(javac, &[], &target.module, Format::Gradle);
-    // Raw `javac` prints `path:line: error: …`, the same form Gradle forwards.
-    step.args.push("-encoding".into());
-    step.args.push("UTF-8".into());
-    step.args.push("-d".into());
-    step.args.push(target.out_dir.to_string_lossy().into_owned());
-    step.args.push("-cp".into());
-    step.args.push(classpath.to_owned());
-    // Classes of the module that were never built (or are older than their source) are read
-    // from its sources; only `file` is written, so a test compile never puts main classes
-    // into test-classes.
-    let sources = source_roots(target);
-    if !sources.is_empty() {
-        let separator = if cfg!(windows) { ";" } else { ":" };
-        step.args.push("-sourcepath".into());
-        step.args.push(sources.iter().map(|p| p.to_string_lossy()).collect::<Vec<_>>().join(separator));
-        step.args.push("-implicit:none".into());
-    }
-    if let Some(version) = target.java_version {
-        step.args.push("--release".into());
-        step.args.push(version.to_string());
-    }
-    step.args.push(file.to_string_lossy().into_owned());
-    step.env = target.top.env.clone();
-    Ok(step)
-}
-
-/// The module's Java source folders that exist, generated ones included; test sources see
-/// the main ones too.
-fn source_roots(target: &SingleFileTarget) -> Vec<PathBuf> {
-    let scopes: &[(&str, &str)] = if target.test {
-        &[("src/test/java", "target/generated-test-sources"), ("src/main/java", "target/generated-sources")]
-    } else {
-        &[("src/main/java", "target/generated-sources")]
-    };
-    let mut roots = Vec::new();
-    for (src, generated) in scopes {
-        roots.push(target.module.join(src));
-        let generated = target.module.join(generated);
-        let mut dirs: Vec<PathBuf> =
-            fs::read_dir(&generated).into_iter().flatten().flatten().map(|d| d.path()).filter(|p| p.is_dir()).collect();
-        dirs.sort();
-        roots.extend(dirs);
-    }
-    roots.retain(|p| p.is_dir());
-    roots
-}
-
-/// Resolves the classpath and plans the `javac` invocation for one Java source.
-pub fn compile_file_plan(root: &Path, model: &BuildModel, file: &Path) -> IdeResult<BuildPlan> {
-    let target = single_file_target(root, model, file)?;
-    let classpath = single_file_classpath(root, model, &target)?;
-    let javac = find_javac(&target.top.env);
-    let name = file.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
-    Ok(BuildPlan {
-        system: BuildSystem::Maven,
-        title: format!("Compile {name}"),
-        steps: vec![javac_step(&target, file, &classpath, &javac)?],
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn write(root: &Path, rel: &str, value: &str) {
-        let path = root.join(rel);
-        fs::create_dir_all(path.parent().unwrap()).unwrap();
-        fs::write(path, value).unwrap();
-    }
-
-    fn fixture(root: &Path) -> BuildModel {
-        write(
-            root,
-            "pom.xml",
-            r#"<project><groupId>demo</groupId><artifactId>parent</artifactId><version>1</version>
-            <packaging>pom</packaging><modules><module>lib</module><module>app</module></modules></project>"#,
-        );
-        write(
-            root,
-            "lib/pom.xml",
-            r#"<project><parent><groupId>demo</groupId><artifactId>parent</artifactId><version>1</version></parent>
-            <artifactId>lib</artifactId></project>"#,
-        );
-        write(
-            root,
-            "app/pom.xml",
-            r#"<project><parent><groupId>demo</groupId><artifactId>parent</artifactId><version>1</version></parent>
-            <artifactId>app</artifactId><dependencies><dependency><groupId>demo</groupId><artifactId>lib</artifactId><version>1</version></dependency></dependencies></project>"#,
-        );
-        write(root, "app/src/main/java/demo/Main.java", "class Main {}");
-        write(root, "app/src/test/java/demo/MainTest.java", "class MainTest {}");
-        write(root, "lib/target/classes/Lib.class", "built");
-        crate::load(root, &root.join("cache"), None)
-    }
-
-    #[test]
-    fn target_finds_the_owning_module_and_the_test_scope() {
-        let dir = tempfile::tempdir().unwrap();
-        let root = dir.path();
-        let model = fixture(root);
-        let main = single_file_target(root, &model, &root.join("app/src/main/java/demo/Main.java")).unwrap();
-        assert_eq!(main.module, root.join("app"));
-        assert!(!main.test);
-        assert_eq!(main.out_dir, root.join("app/target/classes"));
-        let test = single_file_target(root, &model, &root.join("app/src/test/java/demo/MainTest.java")).unwrap();
-        assert!(test.test);
-        assert_eq!(test.out_dir, root.join("app/target/test-classes"));
-    }
-
-    #[test]
-    fn target_rejects_non_java_missing_and_unlinked_files() {
-        let dir = tempfile::tempdir().unwrap();
-        let root = dir.path();
-        let model = fixture(root);
-        write(root, "app/pom.xml", "<project/>");
-        assert!(single_file_target(root, &model, &root.join("app/pom.xml")).is_err());
-        assert!(single_file_target(root, &model, &root.join("app/src/main/java/demo/Missing.java")).is_err());
-        write(root, "other/Main.java", "class Main {}");
-        assert!(single_file_target(root, &model, &root.join("other/Main.java")).is_err());
-    }
-
-    #[test]
-    fn javac_prefers_the_module_jdk_and_scopes_test_sources() {
-        let dir = tempfile::tempdir().unwrap();
-        let root = dir.path();
-        let model = fixture(root);
-        let file = root.join("app/src/test/java/demo/MainTest.java");
-        let target = single_file_target(root, &model, &file).unwrap();
-        let jdk = root.join("jdk");
-        fs::create_dir_all(jdk.join("bin")).unwrap();
-        let exe = if cfg!(windows) { "javac.exe" } else { "javac" };
-        fs::write(jdk.join("bin").join(exe), "fake").unwrap();
-        let mut target = target;
-        target.top.env.insert("JAVA_HOME".into(), jdk.to_string_lossy().into_owned());
-        let step = javac_step(&target, &file, "/repo/a.jar", &find_javac(&target.top.env)).unwrap();
-        assert!(step.program.ends_with(exe));
-        assert!(target.out_dir.is_dir());
-        let args = step.args.join(" ");
-        assert!(args.contains("-encoding UTF-8"), "{args}");
-        assert!(args.contains("-d ") && args.contains("test-classes"), "{args}");
-        assert!(args.contains("-cp /repo/a.jar"), "{args}");
-        assert!(args.contains("MainTest.java"), "{args}");
-        // Test sources resolve their own and the main sources, without writing them.
-        let sourcepath = step.args.iter().position(|a| a == "-sourcepath").map(|i| step.args[i + 1].clone());
-        let roots = sourcepath.expect("a -sourcepath");
-        assert!(roots.contains("src/test/java") && roots.contains("src/main/java"), "{roots}");
-        assert!(step.args.iter().any(|a| a == "-implicit:none"), "{args}");
-        // No `JAVA_HOME`: plain `javac` from `PATH`.
-        assert_eq!(find_javac(&BTreeMap::new()), exe);
-    }
-
-    /// The classpath probe runs the project's Maven command with `-pl … -am`
-    /// `dependency:build-classpath`; the fake `mvnw` below only records its
-    /// arguments and writes a canned classpath file for the `-pl` module.
-    #[cfg(unix)]
-    #[test]
-    fn classpath_probe_writes_one_file_per_module_and_reads_the_compiled_one() {
-        use std::os::unix::fs::PermissionsExt;
-
-        let dir = tempfile::tempdir().unwrap();
-        let root = dir.path();
-        fixture(root);
-        let script = root.join("mvnw");
-        fs::write(
-            &script,
-            "#!/bin/sh\npl='.'\nwhile [ $# -gt 0 ]; do\nif [ \"$1\" = \"-pl\" ]; then pl=\"$2\"; shift 2; else shift; fi\ndone\nmkdir -p \"$pl/target\"\nprintf '/repo/a.jar:/repo/b.jar' > \"$pl/target/ide-compile-cp.txt\"\n",
-        )
-        .unwrap();
-        fs::set_permissions(&script, fs::Permissions::from_mode(0o755)).unwrap();
-        let model = crate::load(root, &root.join("cache"), None);
-        let file = root.join("app/src/main/java/demo/Main.java");
-        let target = single_file_target(root, &model, &file).unwrap();
-        assert!(target.top.command.ends_with("mvnw"));
-        assert_eq!(target.pl, "app");
-        let cp = single_file_classpath(root, &model, &target).unwrap();
-        let separator = ':';
-        // Reactor class directories first, so fresh outputs shadow installed snapshots.
-        let lib = root.join("lib/target/classes").to_string_lossy().into_owned();
-        assert!(cp.starts_with(&lib), "{cp}");
-        // The module's own classes come first once they exist.
-        fs::create_dir_all(root.join("app/target/classes")).unwrap();
-        let cp = single_file_classpath(root, &model, &target).unwrap();
-        let own = root.join("app/target/classes").to_string_lossy().into_owned();
-        assert!(cp.starts_with(&format!("{own}:{lib}")), "{cp}");
-        assert!(cp.contains("/repo/a.jar"), "{cp}");
-        assert!(cp.contains("/repo/b.jar"), "{cp}");
-        assert!(cp.split(separator).count() >= 3, "{cp}");
-    }
-}
@@ -1,253 +0,0 @@
-//! Up-to-date checks for menu builds (`Build Project` / `Build Module`, #2476).
-//!
-//! Menu builds have no fingerprint record on the launch path, so a second
-//! click always pays a full offline Maven run. This module stores one JSON
-//! record per scope (project, or one module file's build) after a successful
-//! build and compares it before the next build; on a match the build is
-//! skipped entirely. Like launch reuse, timestamp-preserving external edits
-//! are re-stamped first so Maven actually recompiles them on the next run.
-
-use super::*;
-use std::fs;
-
-/// Record of the last successful menu build of one scope.
-#[derive(serde::Serialize, serde::Deserialize)]
-struct Record {
-    fingerprint: LaunchFingerprint,
-    /// Output folders of the built projects that existed after the build, relative to the
-    /// project. Deleting one outside the IDE (`mvn clean` in a terminal) leaves every input
-    /// unchanged, so a build is skipped only while they are all still there.
-    #[serde(default)]
-    outputs: Vec<PathBuf>,
-}
-
-/// The build's output folders that exist now, relative to `root`.
-fn existing_outputs(root: &Path, fingerprint: &LaunchFingerprint) -> Vec<PathBuf> {
-    fingerprint
-        .project_dirs()
-        .flat_map(|dir| ["target/classes", "target/test-classes"].map(|out| dir.join(out)))
-        .filter(|rel| root.join(rel).is_dir())
-        .collect()
-}
-
-fn record_path(cache: &Path, root: &Path, file: Option<&Path>) -> PathBuf {
-    let base = cache.join("menu-build").join("records");
-    match file {
-        Some(f) => base.join(f.strip_prefix(root).unwrap_or(f)).with_extension("json"),
-        None => base.join("project.json"),
-    }
-}
-
-/// Re-stamps files whose content changed without advancing mtime (git
-/// checkout, external sync): timestamp-incremental Maven would otherwise skip
-/// them as "unchanged" and the rebuild would compile nothing.
-fn restamp(root: &Path, edits: &[PathBuf]) {
-    let now = std::time::SystemTime::now();
-    for rel in edits {
-        let path = root.join(rel);
-        let _ = fs::File::options().write(true).open(&path).and_then(|f| f.set_modified(now)).or_else(|_| {
-            fs::OpenOptions::new()
-                .create(true)
-                .truncate(false)
-                .write(true)
-                .open(&path)
-                .and_then(|f| f.set_modified(now))
-        });
-    }
-}
-
-/// Whether the last successful menu build of this scope is still fresh: its
-/// record exists and the fingerprint matches. On a mismatch caused by
-/// timestamp-preserving external edits the files are re-stamped first, so the
-/// rebuild Maven runs actually recompiles them.
-pub fn menu_up_to_date(
-    cache: &Path,
-    root: &Path,
-    model: &BuildModel,
-    file: Option<&Path>,
-    cancel: &CancellationToken,
-) -> bool {
-    let current = match menu_fingerprint(root, model, file, cancel) {
-        Ok(Some(current)) => current,
-        _ => return false,
-    };
-    let bytes = match fs::read(record_path(cache, root, file)) {
-        Ok(bytes) => bytes,
-        _ => return false,
-    };
-    let record: Record = match serde_json::from_slice(&bytes) {
-        Ok(record) => record,
-        _ => return false,
-    };
-    if record.fingerprint != current {
-        restamp(root, &record.fingerprint.mtime_preserved_edits(&current));
-        return false;
-    }
-    record.outputs.iter().all(|out| root.join(out).is_dir())
-}
-
-/// Records a successful menu build as the baseline for future up-to-date
-/// checks. Failures are swallowed: a missing record only costs one Maven run.
-pub fn record_menu_build(
-    cache: &Path,
-    root: &Path,
-    model: &BuildModel,
-    file: Option<&Path>,
-    cancel: &CancellationToken,
-) {
-    let current = match menu_fingerprint(root, model, file, cancel) {
-        Ok(Some(current)) => current,
-        _ => return,
-    };
-    // A torn write fails to parse later and is treated as "no record", so a
-    // plain write is enough.
-    let path = record_path(cache, root, file);
-    if path.parent().is_some_and(|p| fs::create_dir_all(p).is_err()) {
-        return;
-    }
-    let outputs = existing_outputs(root, &current);
-    let bytes = match serde_json::to_vec(&Record { fingerprint: current, outputs }) {
-        Ok(bytes) => bytes,
-        _ => return,
-    };
-    let _ = fs::write(&path, bytes);
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn write(root: &Path, rel: &str, value: &str) {
-        let path = root.join(rel);
-        fs::create_dir_all(path.parent().unwrap()).unwrap();
-        fs::write(path, value).unwrap();
-    }
-
-    fn fixture(root: &Path) -> BuildModel {
-        maven_two_module(root, "int x;");
-        BuildModel { maven: Some(maven::load(root)), ..Default::default() }
-    }
-
-    fn maven_two_module(root: &Path, extra_app: &str) {
-        write(
-            root,
-            "pom.xml",
-            r#"<project><modelVersion>4.0.0</modelVersion><groupId>t</groupId><artifactId>root</artifactId><version>1</version><packaging>pom</packaging><modules><module>app</module><module>lib</module></modules></project>"#,
-        );
-        write(
-            root,
-            "app/pom.xml",
-            r#"<project><modelVersion>4.0.0</modelVersion><parent><groupId>t</groupId><artifactId>root</artifactId><version>1</version></parent><artifactId>app</artifactId><dependencies><dependency><groupId>t</groupId><artifactId>lib</artifactId><version>1</version></dependency></dependencies></project>"#,
-        );
-        write(
-            root,
-            "lib/pom.xml",
-            r#"<project><modelVersion>4.0.0</modelVersion><parent><groupId>t</groupId><artifactId>root</artifactId><version>1</version></parent><artifactId>lib</artifactId></project>"#,
-        );
-        write(root, "app/src/main/java/t/A.java", &format!("package t; public class A {{ {extra_app} }}"));
-        write(root, "lib/src/main/java/t/L.java", "package t; public class L {}");
-    }
-
-    #[test]
-    fn record_then_skip_without_changes() {
-        let dir = tempfile::tempdir().unwrap();
-        let root = dir.path();
-        let model = fixture(root);
-        let cache = root.join("cache");
-        let file = root.join("app/src/main/java/t/A.java");
-        let cancel = CancellationToken::new();
-
-        assert!(!menu_up_to_date(&cache, root, &model, Some(&file), &cancel));
-        record_menu_build(&cache, root, &model, Some(&file), &cancel);
-        assert!(menu_up_to_date(&cache, root, &model, Some(&file), &cancel));
-        // The project scope is independent of the module scope.
-        assert!(!menu_up_to_date(&cache, root, &model, None, &cancel));
-        record_menu_build(&cache, root, &model, None, &cancel);
-        assert!(menu_up_to_date(&cache, root, &model, None, &cancel));
-    }
-
-    #[test]
-    fn deleted_outputs_invalidate_the_record() {
-        let dir = tempfile::tempdir().unwrap();
-        let root = dir.path();
-        let model = fixture(root);
-        let cache = root.join("cache");
-        let cancel = CancellationToken::new();
-        for out in ["app/target/classes/t", "lib/target/classes/t", "app/target/test-classes"] {
-            fs::create_dir_all(root.join(out)).unwrap();
-        }
-        record_menu_build(&cache, root, &model, None, &cancel);
-        assert!(menu_up_to_date(&cache, root, &model, None, &cancel));
-        // `mvn clean` outside the IDE: no input changed, but the classes are gone.
-        fs::remove_dir_all(root.join("lib/target")).unwrap();
-        assert!(!menu_up_to_date(&cache, root, &model, None, &cancel));
-        fs::create_dir_all(root.join("lib/target/classes")).unwrap();
-        assert!(menu_up_to_date(&cache, root, &model, None, &cancel));
-    }
-
-    #[test]
-    fn edit_invalidates_and_rerecord_restores_skip() {
-        let dir = tempfile::tempdir().unwrap();
-        let root = dir.path();
-        let model = fixture(root);
-        let cache = root.join("cache");
-        let file = root.join("app/src/main/java/t/A.java");
-        let cancel = CancellationToken::new();
-
-        record_menu_build(&cache, root, &model, Some(&file), &cancel);
-        assert!(menu_up_to_date(&cache, root, &model, Some(&file), &cancel));
-        write(root, "app/src/main/java/t/A.java", "package t; public class A { int y; }");
-        assert!(!menu_up_to_date(&cache, root, &model, Some(&file), &cancel));
-        record_menu_build(&cache, root, &model, Some(&file), &cancel);
-        assert!(menu_up_to_date(&cache, root, &model, Some(&file), &cancel));
-    }
-
-    #[test]
-    fn mtime_preserved_edit_forces_rebuild_and_restamps() {
-        let dir = tempfile::tempdir().unwrap();
-        let root = dir.path();
-        let model = fixture(root);
-        let cache = root.join("cache");
-        let rel = "app/src/main/java/t/A.java";
-        let file = root.join(rel);
-        let cancel = CancellationToken::new();
-
-        record_menu_build(&cache, root, &model, Some(&file), &cancel);
-        let before = fs::metadata(&file).unwrap().modified().unwrap();
-        // Same length, same mtime, different content: an external edit that
-        // preserved the timestamp.
-        write(root, rel, "package t; public class A { int z; }");
-        fs::File::options().write(true).open(&file).and_then(|f| f.set_modified(before)).unwrap();
-        assert!(!menu_up_to_date(&cache, root, &model, Some(&file), &cancel));
-        assert!(fs::metadata(&file).unwrap().modified().unwrap() > before);
-    }
-
-    #[test]
-    fn corrupt_record_never_skips() {
-        let dir = tempfile::tempdir().unwrap();
-        let root = dir.path();
-        let model = fixture(root);
-        let cache = root.join("cache");
-        let file = root.join("app/src/main/java/t/A.java");
-        let cancel = CancellationToken::new();
-
-        fs::create_dir_all(cache.join("menu-build").join("records").join("app/src/main/java/t")).unwrap();
-        fs::write(cache.join("menu-build").join("records").join("app/src/main/java/t/A.json"), b"{not json").unwrap();
-        assert!(!menu_up_to_date(&cache, root, &model, Some(&file), &cancel));
-    }
-
-    #[test]
-    fn unsupported_builds_never_skip() {
-        let dir = tempfile::tempdir().unwrap();
-        let root = dir.path();
-        let model = fixture(root);
-        write(root, "other/Main.java", "public class Main {}");
-        let cache = root.join("cache");
-        let cancel = CancellationToken::new();
-
-        // A file outside any non-aggregator module has no fingerprint.
-        let stray = root.join("other/Main.java");
-        record_menu_build(&cache, root, &model, Some(&stray), &cancel);
-        assert!(!menu_up_to_date(&cache, root, &model, Some(&stray), &cancel));
-    }
-}
@@ -8,24 +8,6 @@ def canon = { File f -> f.canonicalPath }
 // the identity path (`:lib:core`, `:buildSrc`) tells them apart and addresses their tasks
 // from the root build. Internal API, hence the fallback.
 def identity = { Project p -> try { p.identityPath.toString() } catch (ignored) { p.path } }
-// The task copying a source set's resources and its output folder, when it changes them on the
-// way (filters, `expand`, renames, includes / excludes, extra sources): jdtls copies resources as
-// they are, so launches take them from Gradle. Internal API, hence the fallback.
-def processedResources = { Project p, s ->
-    try {
-        def task = p.tasks.findByName(s.processResourcesTaskName)
-        if (task == null) return null
-        def specs = 0
-        def changes = task.mainSpec.sourcePaths.size() > 1
-        task.rootSpec.buildRootResolver().walk { r ->
-            specs++
-            changes |= !r.allCopyActions.isEmpty() || !r.allIncludes.isEmpty() || !r.allExcludes.isEmpty() ||
-                !r.allIncludeSpecs.isEmpty() || !r.allExcludeSpecs.isEmpty() || r.destPath.segments.length > 0
-        }
-        // The root and main specs exist for every task; more come from `from(…) { … }`.
-        (changes || specs > 2) ? [task: task.name, dir: canon(task.destinationDir)] : null
-    } catch (ignored) { null }
-}

 def describe = { Project p ->
    def m = [path: identity(p), dir: canon(p.projectDir), buildDir: canon(p.layout.buildDirectory.get().asFile)]
@@ -44,10 +26,7 @@ def describe = { Project p ->
            def test = s.name == 'test' || s.name == 'testFixtures' || suites.contains(s.name) ||
                s.name.endsWith('Test') || s.name.endsWith('Tests') ||
                (!src.isEmpty() && src.every { ideaTests.contains(it) })
-            def set = [name: s.name, test: test, src: src, res: res]
-            def processed = processedResources(p, s)
-            if (processed != null) set.processed = processed
-            set
+            [name: s.name, test: test, src: src, res: res]
        }
    }
    try {
@@ -109,11 +109,11 @@ fn strip_comments(text: &str) -> String {
 /// Quoted string literals in `s`.
 fn literals(s: &str) -> Vec<String> {
    let mut out = Vec::new();
-    let mut rest = s;
-    while let Some(start) = rest.find(['"', '\'']) {
-        let Some((value, used)) = literal(&rest[start..]) else { break };
-        out.push(value);
-        rest = &rest[start + used..];
+    let mut chars = s.chars();
+    while let Some(c) = chars.next() {
+        if c == '"' || c == '\'' {
+            out.push(chars.by_ref().take_while(|&n| n != c).collect());
+        }
    }
    out
 }
@@ -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 {
@@ -335,19 +342,6 @@ pub struct ReportedSourceSet {
    /// Absolute resource folders.
    #[serde(default)]
    pub res: Vec<String>,
-    /// Set when Gradle changes the resources while copying them (filters, `expand`, renames,
-    /// includes / excludes, extra sources), which the Java language server's copy does not.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub processed: Option<ProcessedResources>,
-}
-
-/// The task that copies a source set's resources, and where it writes them.
-#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub struct ProcessedResources {
-    /// Task name in its project (`processResources`).
-    pub task: String,
-    /// Absolute output folder.
-    pub dir: String,
 }

 const MODEL_LINE: &str = "@openidea-model\t";
@@ -441,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());
@@ -472,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> {
@@ -578,12 +502,11 @@ fn is_dependency_configuration(name: &str) -> bool {
 /// `(group, artifact, version)` of the external dependencies a build script declares:
 /// `implementation 'g:a:v'`, `api("g:a:v:classifier@jar")`, and the map notation
 /// `implementation group: 'g', name: 'a', version: 'v'` (Groovy) / `group = "g", …` (Kotlin).
-/// Versions written as `${gsonVersion}` are filled in from `properties` (`ext` values, see
-/// [`script_properties`]); ranges, unknown names and catalog aliases (`libs.x`) are skipped.
-pub fn script_dependencies(text: &str, properties: &BTreeMap<String, String>) -> Vec<(String, String, String)> {
+/// Versions with interpolations, ranges and catalog aliases (`libs.x`) are skipped.
+pub fn script_dependencies(text: &str) -> Vec<(String, String, String)> {
    let text = strip_comments(text);
    let mut out = Vec::new();
-    for line in text.lines().flat_map(statements) {
+    for line in text.lines().flat_map(|l| l.split(['{', ';'])) {
        let line = line.trim_start();
        let name: String = line.chars().take_while(|c| c.is_ascii_alphanumeric() || *c == '_').collect();
        if name.is_empty() || !is_dependency_configuration(&name) {
@@ -605,7 +528,6 @@ pub fn script_dependencies(text: &str, properties: &BTreeMap<String, String>) ->
            }),
        };
        if let Some((g, a, v)) = coordinate {
-            let v = interpolate(&v, properties);
            let plain = |s: &str| {
                !s.is_empty() && s.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | '_' | '+'))
            };
@@ -617,354 +539,11 @@ pub fn script_dependencies(text: &str, properties: &BTreeMap<String, String>) ->
    out
 }

-/// `line` split at `{` and `;` outside quoted strings, so a `${version}` stays in one piece.
-fn statements(line: &str) -> Vec<&str> {
-    let mut out = Vec::new();
-    let mut start = 0;
-    let mut index = 0;
-    while index < line.len() {
-        let c = line[index..].chars().next().unwrap();
-        if c == '"' || c == '\'' {
-            index += literal(&line[index..]).map_or(line.len() - index, |(_, used)| used);
-            continue;
-        }
-        if matches!(c, '{' | '}' | ';' | '\n') {
-            out.push(&line[start..index]);
-            start = index + c.len_utf8();
-        }
-        index += c.len_utf8();
-    }
-    out.push(&line[start..]);
-    out
-}
-
-/// `apply from: 'x.gradle'` (Groovy) and `apply(from = "x.gradle.kts")` (Kotlin DSL)
-/// targets, as written in the script.
-pub fn applied_scripts(text: &str) -> Vec<String> {
-    let text = strip_comments(text);
-    let mut out = Vec::new();
-    for (index, word) in code_words(&text) {
-        if word != "apply" || !starts_word(&text, index) {
-            continue;
-        }
-        let mut rest = text[index + "apply".len()..].trim_start();
-        if let Some(inner) = rest.strip_prefix('(') {
-            rest = inner.trim_start();
-        }
-        let Some(rest) = rest.strip_prefix("from") else { continue };
-        let Some(rest) = rest.trim_start().strip_prefix(':').or_else(|| rest.trim_start().strip_prefix('=')) else {
-            continue;
-        };
-        let mut rest = rest.trim_start();
-        if let Some(inner) = rest.strip_prefix("file") {
-            let inner = inner.trim_start();
-            if let Some(inner) = inner.strip_prefix('(') {
-                rest = inner.trim_start();
-            }
-        }
-        if let Some((path, _)) = literal(rest) {
-            out.push(path);
-        }
-    }
-    out
-}
-
-/// Literal extra properties declared by Groovy's `ext` or Kotlin's `extra`.
-pub fn script_properties(text: &str) -> BTreeMap<String, String> {
-    let text = strip_comments(text);
-    let mut out = BTreeMap::new();
-    for (index, word) in code_words(&text) {
-        if !starts_word(&text, index) {
-            continue;
-        }
-        let rest = text[index + word.len()..].trim_start();
-        if word == "val" || word == "var" {
-            let (name, rest) = identifier(rest);
-            let Some(rest) = rest.trim_start().strip_prefix("by").map(str::trim_start) else { continue };
-            let Some(rest) = rest.strip_prefix("extra").map(str::trim_start) else { continue };
-            if let Some(rest) = rest.strip_prefix('(')
-                && let Some((value, used)) = literal(rest.trim_start())
-                && rest.trim_start()[used..].trim_start().starts_with(')')
-                && !name.is_empty()
-            {
-                out.insert(name.to_owned(), value);
-            }
-            continue;
-        }
-        if word != "ext" && word != "extra" {
-            continue;
-        }
-        if let Some(block) = rest.strip_prefix('{') {
-            if let Some(end) = matching_brace(block) {
-                out.extend(assignments(&block[..end]));
-            }
-        } else if let Some(rest) = rest.strip_prefix('.') {
-            let (name, rest) = identifier(rest);
-            if let Some(value) = assigned_literal(rest)
-                && !name.is_empty()
-            {
-                out.insert(name.to_owned(), value);
-            }
-        } else if let Some(rest) = rest.strip_prefix('[')
-            && let Some((name, used)) = literal(rest.trim_start())
-            && let Some(rest) = rest.trim_start()[used..].trim_start().strip_prefix(']')
-            && let Some(value) = assigned_literal(rest)
-        {
-            out.insert(name, value);
-        }
-    }
-    out
-}
-
-pub(crate) fn file_properties(build_dir: &Path) -> BTreeMap<String, String> {
-    let text = std::fs::read_to_string(build_dir.join("gradle.properties")).unwrap_or_default();
-    text.lines()
-        .filter_map(|line| {
-            let line = line.trim();
-            if line.starts_with(['#', '!']) {
-                return None;
-            }
-            let separator = line.find(|c: char| c == '=' || c == ':' || c.is_whitespace())?;
-            let (key, rest) = line.split_at(separator);
-            let value = rest.trim_start().trim_start_matches(['=', ':']).trim_start();
-            (!key.is_empty()).then(|| (key.to_owned(), value.to_owned()))
-        })
-        .collect()
-}
-
-/// The build script of a project and, recursively, the scripts it applies with `apply from`,
-/// read from disk: absolute path and text. Targets that do not exist are skipped.
-pub fn scripts_of(root: &Path, project_dir: &Path, build_dir: &Path, build_file: &Path) -> Vec<(PathBuf, String)> {
-    const MAX_SCRIPTS: usize = 256;
-    const MAX_DEPTH: usize = 32;
-    let mut out = Vec::new();
-    let mut seen = std::collections::HashSet::new();
-    let first = normalize(&root.join(build_file));
-    let Ok(identity) = dunce::canonicalize(&first) else { return out };
-    seen.insert(identity);
-    let mut stack = vec![(first, 0)];
-    while let Some((path, depth)) = stack.pop() {
-        let Ok(text) = std::fs::read_to_string(&path) else { continue };
-        if depth < MAX_DEPTH {
-            let mut targets = Vec::new();
-            for spec in applied_scripts(&text) {
-                if seen.len() >= MAX_SCRIPTS {
-                    break;
-                }
-                if let Some(target) = resolve_script(&spec, &path, project_dir, build_dir)
-                    && let Ok(identity) = dunce::canonicalize(&target)
-                    && seen.insert(identity)
-                {
-                    targets.push((target, depth + 1));
-                }
-            }
-            stack.extend(targets.into_iter().rev());
-        }
-        out.push((path, text));
-    }
-    out
-}
-
-/// Relative targets are project-scoped, with a lenient fallback beside the applying script.
-fn resolve_script(spec: &str, script: &Path, project_dir: &Path, build_dir: &Path) -> Option<PathBuf> {
-    let spec = spec.trim();
-    if spec.contains("://") {
-        return None;
-    }
-    let properties = BTreeMap::from([
-        ("rootDir".into(), build_dir.to_string_lossy().into_owned()),
-        ("rootProject.projectDir".into(), build_dir.to_string_lossy().into_owned()),
-        ("projectDir".into(), project_dir.to_string_lossy().into_owned()),
-    ]);
-    let spec = interpolate(spec, &properties);
-    if spec.contains('$') {
-        return None;
-    }
-    let path = Path::new(&spec);
-    if path.is_absolute() {
-        return path.is_file().then(|| normalize(path));
-    }
-    let project_path = normalize(&project_dir.join(path));
-    if project_path.is_file() {
-        return Some(project_path);
-    }
-    let path = normalize(&script.parent()?.join(path));
-    path.is_file().then_some(path)
-}
-
-pub(crate) fn project_build_dir(root: &Path, model: &GradleModel, project: &GradleProject) -> PathBuf {
-    let dir = project.build.as_ref().and_then(|build| model.projects.iter().find(|p| &p.path == build));
-    root.join(dir.map_or(&model.dir, |p| &p.dir))
-}
-
-/// `2.8.9` for `${gsonVersion}` / `$gsonVersion` / `${ext.gsonVersion}`; unknown names and
-/// expressions are left as written, so ranges and catalogs stay skipped.
-fn interpolate(value: &str, properties: &BTreeMap<String, String>) -> String {
-    if !value.contains('$') {
-        return value.to_owned();
-    }
-    let mut out = String::with_capacity(value.len());
-    let mut chars = value.chars().peekable();
-    while let Some(c) = chars.next() {
-        if c != '$' {
-            out.push(c);
-            continue;
-        }
-        let braced = chars.peek() == Some(&'{');
-        if braced {
-            chars.next();
-        }
-        let mut name = String::new();
-        if braced {
-            for n in chars.by_ref() {
-                if n == '}' {
-                    break;
-                }
-                name.push(n);
-            }
-        } else {
-            while let Some(&n) = chars.peek() {
-                if n.is_alphanumeric() || n == '_' || n == '.' {
-                    name.push(n);
-                    chars.next();
-                } else {
-                    break;
-                }
-            }
-        }
-        let key = name.strip_prefix("ext.").or_else(|| name.strip_prefix("extra.")).unwrap_or(&name);
-        let bracket = name.strip_prefix("ext[").or_else(|| name.strip_prefix("extra[")).and_then(|rest| {
-            let (key, used) = literal(rest.trim_start())?;
-            (rest.trim_start()[used..].trim() == "]").then_some(key)
-        });
-        match properties.get(bracket.as_deref().unwrap_or(key)) {
-            Some(v) if !name.is_empty() => out.push_str(v),
-            _ => {
-                out.push('$');
-                if braced {
-                    out.push('{');
-                }
-                out.push_str(&name);
-                if braced {
-                    out.push('}');
-                }
-            }
-        }
-    }
-    out
-}
-
-/// Whether `index` starts a whole word in `text` (not `reapply`, `my.apply`).
-fn starts_word(text: &str, index: usize) -> bool {
-    text[..index].chars().next_back().is_none_or(|c| !(c.is_alphanumeric() || c == '_' || c == '.'))
-}
-
-/// Identifiers outside quoted strings, with their byte positions.
-fn code_words(text: &str) -> Vec<(usize, &str)> {
-    let mut out = Vec::new();
-    let mut index = 0;
-    while index < text.len() {
-        let c = text[index..].chars().next().unwrap();
-        if c == '"' || c == '\'' {
-            index += literal(&text[index..]).map_or(text.len() - index, |(_, used)| used);
-        } else if c.is_alphabetic() || c == '_' {
-            let (word, _) = identifier(&text[index..]);
-            out.push((index, word));
-            index += word.len();
-        } else {
-            index += c.len_utf8();
-        }
-    }
-    out
-}
-
-fn identifier(text: &str) -> (&str, &str) {
-    let end = text.find(|c: char| !(c.is_alphanumeric() || c == '_')).unwrap_or(text.len());
-    text.split_at(end)
-}
-
-fn assigned_literal(text: &str) -> Option<String> {
-    let rest = text.trim_start().strip_prefix('=')?.trim_start();
-    let (value, used) = literal(rest)?;
-    // Do not turn a computed value (`'1.' + suffix`) into a concrete version.
-    let tail = rest[used..].trim_start_matches([' ', '\t', '\r']);
-    (tail.is_empty() || tail.starts_with(['\n', ';', '}'])).then_some(value)
-}
-
-/// The quoted string at the start of `s`, and how many bytes it spans.
-fn literal(s: &str) -> Option<(String, usize)> {
-    let quote = s.chars().next().filter(|c| *c == '"' || *c == '\'')?;
-    let rest = &s[quote.len_utf8()..];
-    let mut index = 0;
-    while index < rest.len() {
-        let c = rest[index..].chars().next()?;
-        if c == quote {
-            return Some((rest[..index].to_owned(), quote.len_utf8() + index + c.len_utf8()));
-        }
-        if c == '\\' {
-            index += c.len_utf8();
-            index += rest[index..].chars().next()?.len_utf8();
-        } else if quote == '"' && rest[index..].starts_with("${") {
-            index += 2;
-            index += matching_brace(&rest[index..])? + 1;
-        } else {
-            index += c.len_utf8();
-        }
-    }
-    None
-}
-
-/// Byte index of the `}` closing a `{` that was already consumed, ignoring quoted text.
-fn matching_brace(text: &str) -> Option<usize> {
-    let mut depth = 1usize;
-    let mut index = 0;
-    while index < text.len() {
-        let c = text[index..].chars().next()?;
-        if c == '"' || c == '\'' {
-            index += literal(&text[index..])?.1;
-            continue;
-        }
-        if c == '{' {
-            depth += 1;
-        } else if c == '}' {
-            depth -= 1;
-            if depth == 0 {
-                return Some(index);
-            }
-        }
-        index += c.len_utf8();
-    }
-    None
-}
-
-/// `name = 'value'` pairs in `text`.
-fn assignments(text: &str) -> Vec<(String, String)> {
-    statements(text)
-        .into_iter()
-        .filter_map(|statement| {
-            let (name, rest) = identifier(statement.trim_start());
-            let value = assigned_literal(rest)?;
-            (!name.is_empty()).then(|| (name.to_owned(), value))
-        })
-        .collect()
-}
-
 /// Every settings and build script of the model (for change detection).
 pub fn build_files(root: &Path, model: &GradleModel) -> Vec<PathBuf> {
    let dir = root.join(&model.dir);
    let mut out: Vec<PathBuf> = SETTINGS_FILES.iter().map(|f| dir.join(f)).filter(|p| p.is_file()).collect();
    out.extend(model.projects.iter().filter_map(|p| p.build_file.as_ref().map(|f| root.join(f))));
-    // Scripts a build script applies are build files too: editing one can change the model.
-    for project in &model.projects {
-        let Some(file) = project.build_file.as_deref() else { continue };
-        let build_dir = project_build_dir(root, model, project);
-        let properties = build_dir.join("gradle.properties");
-        if properties.is_file() {
-            out.push(properties);
-        }
-        let applied = scripts_of(root, &root.join(&project.dir), &build_dir, Path::new(file));
-        out.extend(applied.into_iter().skip(1).map(|(path, _)| path));
-    }
    // The settings of each nested build (its root project's folder).
    for p in model.projects.iter().filter(|p| p.build.as_deref() == Some(p.path.as_str())) {
        let nested = root.join(&p.dir);
@@ -982,8 +561,6 @@ pub fn build_files(root: &Path, model: &GradleModel) -> Vec<PathBuf> {
        catalogs.sort();
        out.extend(catalogs);
    }
-    out.sort();
-    out.dedup();
    out
 }

@@ -1039,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#"
@@ -1168,7 +634,7 @@ dependencies {
    classpath 'not:a:library'
 }
 "#;
-        let deps = script_dependencies(script, &BTreeMap::new());
+        let deps = script_dependencies(script);
        let names: Vec<String> = deps.iter().map(|(g, a, v)| format!("{g}:{a}:{v}")).collect();
        assert_eq!(
            names,
@@ -1182,291 +648,6 @@ dependencies {
        );
    }

-    #[test]
-    fn applied_scripts_read_groovy_and_kotlin_forms() {
-        let script = r#"
-            apply plugin: 'java'
-            apply from: 'gradle/dependencies.gradle'
-            apply from: file('gradle/extra.gradle')
-            apply(from = "gradle/kotlin.gradle.kts")
-            apply(from = file("gradle/kotlin-file.gradle.kts"))
-            // apply from: 'commented.gradle'
-            reapply from: 'not-a-call.gradle'
-        "#;
-        assert_eq!(
-            applied_scripts(script),
-            [
-                "gradle/dependencies.gradle",
-                "gradle/extra.gradle",
-                "gradle/kotlin.gradle.kts",
-                "gradle/kotlin-file.gradle.kts"
-            ]
-        );
-    }
-
-    #[test]
-    fn ext_values_fill_in_dependency_versions() {
-        let script = r#"
-            ext {
-                gsonVersion = '2.8.9'
-                junit = "4.13.2"
-            }
-            ext.logback = '1.4.14'
-            dependencies {
-                implementation "com.google.code.gson:gson:${gsonVersion}"
-                testImplementation "junit:junit:$junit"
-                implementation "ch.qos.logback:logback-classic:${ext.logback}"
-                implementation 'org.plain:literal:1.0'
-                implementation "org.x:unknown:${missing}"
-            }
-        "#;
-        let names: Vec<String> = script_dependencies(script, &script_properties(script))
-            .into_iter()
-            .map(|(g, a, v)| format!("{g}:{a}:{v}"))
-            .collect();
-        assert_eq!(
-            names,
-            [
-                "com.google.code.gson:gson:2.8.9",
-                "junit:junit:4.13.2",
-                "ch.qos.logback:logback-classic:1.4.14",
-                "org.plain:literal:1.0",
-            ]
-        );
-    }
-
-    #[test]
-    fn extra_properties_support_brackets_and_kotlin_delegates() {
-        for declaration in [
-            "ext.x = '1.2'",
-            "ext { x = '1.2' }",
-            "ext[\"x\"] = '1.2'",
-            "extra[\"x\"] = \"1.2\"",
-            "val x by extra(\"1.2\")",
-        ] {
-            let script = format!("{declaration}\ndependencies {{ implementation \"g:a:${{x}}\" }}");
-            assert_eq!(
-                script_dependencies(&script, &script_properties(&script)),
-                [("g".into(), "a".into(), "1.2".into())],
-                "{declaration}"
-            );
-        }
-    }
-
-    #[test]
-    fn parsers_ignore_apply_and_ext_inside_strings() {
-        let script = r#"
-            println "apply from: 'fake.gradle'"
-            println "ext.x = 'bogus'"
-            ext.real = '1'
-        "#;
-        assert!(applied_scripts(script).is_empty());
-        assert_eq!(script_properties(script), BTreeMap::from([("real".into(), "1".into())]));
-    }
-
-    #[test]
-    fn dependency_statements_preserve_interpolation_and_escaped_quotes() {
-        let script = r#"dependencies { implementation "g:a:${v}"; api(group = "g", name = "b", version = "${v}-RC1") }; dependencies { runtimeOnly 'g:c:2' }"#;
-        let properties = BTreeMap::from([("v".into(), "1.2".into())]);
-        assert_eq!(
-            script_dependencies(script, &properties),
-            [
-                ("g".into(), "a".into(), "1.2".into()),
-                ("g".into(), "b".into(), "1.2-RC1".into()),
-                ("g".into(), "c".into(), "2".into())
-            ]
-        );
-        assert_eq!(
-            statements(r#"println "escaped\"; {still quoted}"; implementation 'g:a:1'"#),
-            [r#"println "escaped\"; {still quoted}""#, " implementation 'g:a:1'"]
-        );
-    }
-
-    #[test]
-    fn dependency_versions_skip_unresolved_names_and_expressions() {
-        let script = r#"dependencies {
-            implementation "g:missing:${unknown}"
-            implementation "g:expression:${1 + 2}"
-            implementation "g:cyclic:${cycle}"
-            implementation 'g:range:[1,2)'
-            implementation 'g:dynamic:1.+'
-        }"#;
-        let properties = BTreeMap::from([("cycle".into(), "${cycle}".into())]);
-        assert!(script_dependencies(script, &properties).is_empty());
-    }
-
-    #[test]
-    fn extra_property_references_support_qualified_and_bracket_access() {
-        let script = r#"dependencies {
-            implementation "g:a:${ext.x}"
-            implementation "g:b:${extra.x}"
-            implementation "g:c:${ext['x']}"
-            implementation "g:d:${extra["x"]}"
-        }"#;
-        let properties = BTreeMap::from([("x".into(), "1".into())]);
-        assert_eq!(script_dependencies(script, &properties).len(), 4);
-    }
-
-    #[test]
-    fn applied_scripts_are_read_recursively_and_survive_cycles() {
-        let tmp = tempfile::tempdir().unwrap();
-        let root = tmp.path();
-        std::fs::create_dir_all(root.join("gradle")).unwrap();
-        std::fs::write(root.join("build.gradle"), "apply from: 'gradle/deps.gradle'\n").unwrap();
-        std::fs::write(root.join("gradle/deps.gradle"), "apply from: '$rootDir/gradle/more.gradle'\n").unwrap();
-        std::fs::write(root.join("gradle/more.gradle"), "apply from: 'deps.gradle'\n").unwrap();
-
-        let scripts: Vec<String> = scripts_of(root, root, root, Path::new("build.gradle"))
-            .into_iter()
-            .map(|(path, _)| path.strip_prefix(root).unwrap().to_string_lossy().replace('\\', "/"))
-            .collect();
-        assert_eq!(scripts, ["build.gradle", "gradle/deps.gradle", "gradle/more.gradle"]);
-        assert_eq!(build_files(root, &load(root).unwrap()).len(), 3);
-    }
-
-    #[test]
-    fn applied_paths_prefer_the_project_directory() {
-        let tmp = tempfile::tempdir().unwrap();
-        let root = tmp.path();
-        std::fs::create_dir_all(root.join("gradle")).unwrap();
-        std::fs::write(root.join("build.gradle"), "apply from: 'gradle/deps.gradle'").unwrap();
-        std::fs::write(root.join("gradle/deps.gradle"), "apply from: 'versions.gradle'").unwrap();
-        std::fs::write(root.join("versions.gradle"), "right").unwrap();
-        std::fs::write(root.join("gradle/versions.gradle"), "wrong").unwrap();
-        let scripts = scripts_of(root, root, root, Path::new("build.gradle"));
-        assert_eq!(scripts.len(), 3);
-        assert_eq!(scripts[2].1, "right");
-    }
-
-    #[test]
-    fn nested_applied_paths_are_relative_to_the_project_directory() {
-        let tmp = tempfile::tempdir().unwrap();
-        let root = tmp.path();
-        std::fs::create_dir_all(root.join("gradle")).unwrap();
-        std::fs::write(root.join("build.gradle"), "apply from: 'gradle/a.gradle'").unwrap();
-        std::fs::write(root.join("gradle/a.gradle"), "apply from: 'gradle/b.gradle'").unwrap();
-        std::fs::write(root.join("gradle/b.gradle"), "").unwrap();
-        let scripts = scripts_of(root, root, root, Path::new("build.gradle"));
-        assert_eq!(scripts.len(), 3);
-        assert_eq!(scripts[2].0, root.join("gradle/b.gradle"));
-    }
-
-    #[test]
-    fn applied_paths_fall_back_to_the_applying_script_directory() {
-        let tmp = tempfile::tempdir().unwrap();
-        let root = tmp.path();
-        std::fs::create_dir_all(root.join("gradle")).unwrap();
-        std::fs::write(root.join("build.gradle"), "apply from: 'gradle/a.gradle'").unwrap();
-        std::fs::write(root.join("gradle/a.gradle"), "apply from: 'c.gradle'").unwrap();
-        std::fs::write(root.join("gradle/c.gradle"), "").unwrap();
-        let scripts = scripts_of(root, root, root, Path::new("build.gradle"));
-        assert_eq!(scripts.len(), 3);
-        assert_eq!(scripts[2].0, root.join("gradle/c.gradle"));
-    }
-
-    #[test]
-    fn applied_paths_resolve_gradle_directory_variables() {
-        let tmp = tempfile::tempdir().unwrap();
-        let root = tmp.path();
-        let project = root.join("app");
-        let script = project.join("gradle/deps.gradle");
-        std::fs::create_dir_all(script.parent().unwrap()).unwrap();
-        std::fs::write(root.join("shared.gradle"), "").unwrap();
-        std::fs::write(project.join("local.gradle"), "").unwrap();
-        for prefix in ["$rootDir", "${rootDir}", "$rootProject.projectDir", "${rootProject.projectDir}"] {
-            assert_eq!(
-                resolve_script(&format!("{prefix}/shared.gradle"), &script, &project, root),
-                Some(root.join("shared.gradle")),
-                "{prefix}"
-            );
-        }
-        for prefix in ["$projectDir", "${projectDir}"] {
-            assert_eq!(
-                resolve_script(&format!("{prefix}/local.gradle"), &script, &project, root),
-                Some(project.join("local.gradle")),
-                "{prefix}"
-            );
-        }
-        assert_eq!(
-            resolve_script(root.join("shared.gradle").to_str().unwrap(), &script, &project, root),
-            Some(root.join("shared.gradle"))
-        );
-    }
-
-    #[test]
-    fn applied_scripts_skip_urls_and_missing_files() {
-        let tmp = tempfile::tempdir().unwrap();
-        let root = tmp.path();
-        // Even a local path resembling a URL must not be read.
-        if !cfg!(windows) {
-            for scheme in ["http", "https"] {
-                let local = root.join(format!("{scheme}:/example.com/deps.gradle"));
-                std::fs::create_dir_all(local.parent().unwrap()).unwrap();
-                std::fs::write(local, "implementation 'g:remote:1'").unwrap();
-            }
-        }
-        std::fs::write(root.join("build.gradle"), "apply from: 'http://example.com/deps.gradle'\napply(from = \"https://example.com/deps.gradle\")\napply from: 'missing.gradle'").unwrap();
-        assert_eq!(scripts_of(root, root, root, Path::new("build.gradle")).len(), 1);
-    }
-
-    #[test]
-    fn applied_scripts_deduplicate_self_application_and_path_aliases() {
-        let tmp = tempfile::tempdir().unwrap();
-        let root = tmp.path();
-        std::fs::create_dir_all(root.join("gradle")).unwrap();
-        std::fs::write(
-            root.join("build.gradle"),
-            "apply from: 'build.gradle'\napply from: 'gradle/../build.gradle'\napply from: 'gradle/a.gradle'",
-        )
-        .unwrap();
-        std::fs::write(root.join("gradle/a.gradle"), "apply from: '../build.gradle'").unwrap();
-        assert_eq!(scripts_of(root, root, root, Path::new("build.gradle")).len(), 2);
-    }
-
-    #[cfg(unix)]
-    #[test]
-    fn applied_scripts_deduplicate_symlink_cycles() {
-        let tmp = tempfile::tempdir().unwrap();
-        let root = tmp.path();
-        std::fs::write(root.join("build.gradle"), "apply from: 'alias/build.gradle'").unwrap();
-        std::os::unix::fs::symlink(root, root.join("alias")).unwrap();
-        assert_eq!(scripts_of(root, root, root, Path::new("build.gradle")).len(), 1);
-    }
-
-    #[test]
-    fn applied_script_traversal_bounds_depth_and_total_files() {
-        let tmp = tempfile::tempdir().unwrap();
-        let root = tmp.path();
-        for i in 0..300 {
-            std::fs::write(root.join(format!("{i}.gradle")), format!("apply from: '{}.gradle'", i + 1)).unwrap();
-        }
-        let chain = scripts_of(root, root, root, Path::new("0.gradle"));
-        assert_eq!(chain.len(), 33);
-        let fanout: String = (0..300).map(|i| format!("apply from: '{i}.gradle'\n")).collect();
-        std::fs::write(root.join("build.gradle"), fanout).unwrap();
-        assert_eq!(scripts_of(root, root, root, Path::new("build.gradle")).len(), 256);
-    }
-
-    #[test]
-    fn applied_scripts_use_their_composite_build_root() {
-        let tmp = tempfile::tempdir().unwrap();
-        let root = tmp.path();
-        std::fs::create_dir_all(root.join("included/app")).unwrap();
-        std::fs::write(root.join("build.gradle"), "").unwrap();
-        std::fs::write(root.join("included/build.gradle"), "").unwrap();
-        std::fs::write(root.join("included/app/build.gradle"), "apply from: \"${rootDir}/deps.gradle\"").unwrap();
-        std::fs::write(root.join("included/deps.gradle"), "implementation 'g:included:1'").unwrap();
-        let mut model = load(root).unwrap();
-        for (path, dir) in [(":included", "included"), (":included:app", "included/app")] {
-            let mut project = project_at(root, path.into(), path.into(), &root.join(dir));
-            project.build = Some(":included".into());
-            model.projects.push(project);
-        }
-        assert!(build_files(root, &model).contains(&root.join("included/deps.gradle")));
-        let model = crate::BuildModel { maven: None, gradle: vec![model] };
-        assert_eq!(crate::dependency_coordinates(root, &model)[0].artifact_id, "included");
-    }
-
    use super::*;

    #[test]
@@ -126,7 +126,6 @@ fn project_path(text: &str) -> String {
 /// `configuration` and returns its tree.
 pub fn gradle_dependencies(
    root: &Path,
-    model: &gradle::GradleModel,
    options: &SyncOptions,
    project: &str,
    configuration: &str,
@@ -138,6 +137,7 @@ pub fn gradle_dependencies(
    if !project.starts_with(':') || project.chars().any(char::is_whitespace) {
        return Err(IdeError::invalid(format!("not a Gradle project path: {project}")));
    }
+    let model = gradle::load(root).ok_or_else(|| IdeError::not_found("no Gradle build in this project"))?;
    let task = if project == ":" { ":dependencies".to_owned() } else { format!("{project}:dependencies") };
    let mut args: Vec<String> =
        vec!["--console=plain".into(), "-q".into(), task, "--configuration".into(), configuration.into()];
@@ -226,12 +226,8 @@ runtimeClasspath - Runtime classpath of source set 'main'.
        let tmp = tempfile::tempdir().unwrap();
        let options = SyncOptions::default();
        let cancel = CancellationToken::new();
-        assert!(
-            gradle_dependencies(tmp.path(), &Default::default(), &options, ":", "x --init-script y", &cancel).is_err()
-        );
-        assert!(
-            gradle_dependencies(tmp.path(), &Default::default(), &options, "app", "runtimeClasspath", &cancel).is_err()
-        );
+        assert!(gradle_dependencies(tmp.path(), &options, ":", "x --init-script y", &cancel).is_err());
+        assert!(gradle_dependencies(tmp.path(), &options, "app", "runtimeClasspath", &cancel).is_err());
    }

    #[cfg(unix)]
@@ -250,15 +246,8 @@ runtimeClasspath - Runtime classpath of source set 'main'.
            offline: true,
            ..Default::default()
        };
-        let tree = gradle_dependencies(
-            root,
-            &gradle::load(root).unwrap(),
-            &options,
-            ":app",
-            "testRuntimeClasspath",
-            &CancellationToken::new(),
-        )
-        .unwrap();
+        let tree =
+            gradle_dependencies(root, &options, ":app", "testRuntimeClasspath", &CancellationToken::new()).unwrap();
        assert_eq!(tree, vec![dep("org.a", "b", Some("1.0"))]);
        assert_eq!(
            std::fs::read_to_string(root.join("args")).unwrap().trim(),
@@ -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, 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,116 +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",
-                        crate::maven::LOCAL_REPO_TRACKING_ARG,
-                        "-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]
@@ -20,9 +20,7 @@ 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 +38,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 +53,31 @@ 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 = settings.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 profiles = sync::maven_profiles(cache_dir);
+        let mut m = maven::load_with(root, maven_repo.or_else(maven::default_local_repo), &profiles);
        maven::UnlinkedProjects::from_model(&m, settings).filter(&mut m);
-        // 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`.
@@ -147,8 +92,7 @@ pub struct DependencyCoordinate {

 /// The external libraries of `model`, sorted and deduplicated: Maven dependencies
 /// (with the transitive ones the last sync read), except the build's own modules,
-/// `pom` imports and `system` scope; dependencies declared in the Gradle build scripts,
-/// including the scripts they pull in with `apply from`.
+/// `pom` imports and `system` scope; dependencies declared in the Gradle build scripts.
 pub fn dependency_coordinates(root: &Path, model: &BuildModel) -> Vec<DependencyCoordinate> {
    let mut out = Vec::new();
    if let Some(m) = &model.maven {
@@ -177,27 +121,12 @@ pub fn dependency_coordinates(root: &Path, model: &BuildModel) -> Vec<Dependency
            });
        }
    }
-    for g in &model.gradle {
-        for p in &g.projects {
-            let Some(build_file) = p.build_file.as_deref() else { continue };
-            let build_dir = gradle::project_build_dir(root, g, p);
-            let scripts = gradle::scripts_of(root, &root.join(&p.dir), &build_dir, Path::new(build_file));
-            // The script's own `ext` values win over the scripts it applies.
-            let mut properties = std::collections::BTreeMap::new();
-            for (_, text) in scripts.iter().rev() {
-                properties.extend(gradle::script_properties(text));
-            }
-            properties.extend(gradle::file_properties(&build_dir));
-            for (_, text) in &scripts {
-                out.extend(gradle::script_dependencies(text, &properties).into_iter().map(
-                    |(group_id, artifact_id, version)| DependencyCoordinate {
-                        gradle: true,
-                        group_id,
-                        artifact_id,
-                        version,
-                    },
-                ));
-            }
+    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)| {
+                DependencyCoordinate { gradle: true, group_id, artifact_id, version }
+            }));
        }
    }
    out.sort();
@@ -218,50 +147,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 settings_profiles_and_checkbox_choices_control_modules_before_sync() {
-        let tmp = tempfile::tempdir().unwrap();
-        let root = tmp.path();
-        std::fs::create_dir(root.join("extra")).unwrap();
-        std::fs::write(root.join("extra/pom.xml"), "<project><artifactId>extra</artifactId></project>").unwrap();
-        std::fs::write(
-            root.join("pom.xml"),
-            r#"<project><artifactId>root</artifactId><packaging>pom</packaging>
-            <profiles><profile><id>extra</id><modules><module>extra</module></modules></profile></profiles></project>"#,
-        )
-        .unwrap();
-        let cache = root.join("cache");
-        let settings = ide_core::settings::MavenSettings { active_profiles: "extra".into(), ..Default::default() };
-        let modules = |settings: &ide_core::settings::MavenSettings| {
-            load_linked(root, &cache, None, settings, &Default::default()).maven.unwrap().projects[0].modules.clone()
-        };
-        assert!(modules(&Default::default()).is_empty());
-        assert_eq!(modules(&settings), ["extra/pom.xml"]);
-        assert_eq!(maven::load_linked(root, &settings).projects[0].modules, ["extra/pom.xml"]);
-        save_maven_profiles(&cache, &["!extra".into()]).unwrap();
-        assert!(modules(&settings).is_empty());
-    }
-
    #[test]
    fn detects_build_systems_and_build_files() {
        let tmp = tempfile::tempdir().unwrap();
@@ -273,7 +158,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")));
    }
@@ -320,7 +205,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()
@@ -328,39 +213,4 @@ mod tests {
            .collect();
        assert_eq!(names, ["M org.b:y:2", "M org.c:z:3", "G org.a:x:1.0"]);
    }
-
-    #[test]
-    fn dependency_coordinates_read_scripts_brought_in_by_apply_from() {
-        let tmp = tempfile::tempdir().unwrap();
-        let root = tmp.path();
-        std::fs::create_dir_all(root.join("gradle")).unwrap();
-        std::fs::write(root.join("build.gradle"), "apply from: 'gradle/dependencies.gradle'\n").unwrap();
-        std::fs::write(
-            root.join("gradle/dependencies.gradle"),
-            "ext { gson = '2.8.9' }\ndependencies { implementation \"com.google.code.gson:gson:${gson}\" }\n",
-        )
-        .unwrap();
-        let model = BuildModel { maven: None, gradle: gradle::load(root).into_iter().collect() };
-        let names: Vec<String> = dependency_coordinates(root, &model)
-            .into_iter()
-            .map(|c| format!("{}:{}:{}", c.group_id, c.artifact_id, c.version))
-            .collect();
-        assert_eq!(names, ["com.google.code.gson:gson:2.8.9"]);
-    }
-
-    #[test]
-    fn gradle_properties_override_script_extra_values() {
-        let tmp = tempfile::tempdir().unwrap();
-        let root = tmp.path();
-        std::fs::write(root.join("build.gradle"), "ext.v = 'wrong'\napply from: 'deps.gradle'").unwrap();
-        std::fs::write(
-            root.join("deps.gradle"),
-            "ext.v = 'alsoWrong'\nimplementation \"g:a:${v}\"\nimplementation \"g:b:${onlyInProperties}\"",
-        )
-        .unwrap();
-        std::fs::write(root.join("gradle.properties"), "# versions\nv = 1.2\nonlyInProperties: 2.3\n").unwrap();
-        let model = BuildModel { maven: None, gradle: gradle::load(root).into_iter().collect() };
-        let versions: Vec<_> = dependency_coordinates(root, &model).into_iter().map(|c| c.version).collect();
-        assert_eq!(versions, ["1.2", "2.3"]);
-    }
 }
@@ -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};
@@ -16,16 +15,6 @@ use std::io::Read;
 use std::path::{Path, PathBuf};
 use std::sync::{Mutex, OnceLock};

-pub mod sources;
-
-/// Lets the IDE's own Maven runs (Reload, Build) use what the local repository already
-/// has. Maven 3.9 re-resolves an artifact whose recorded origin repository (`_remote.repositories`)
-/// isn't declared in the build, such as a vendor jar downloaded through another project or
-/// installed by hand, and fails when no declared repository has it. Tracking under another
-/// file name makes such artifacts count as locally installed. Maven goals the user runs keep
-/// plain Maven's behaviour.
-pub const LOCAL_REPO_TRACKING_ARG: &str = "-Daether.enhancedLocalRepository.trackingFilename=openidea.repositories";
-
 /// Phases shown under "Lifecycle" (IDEA's default list).
 pub const LIFECYCLE: &[&str] =
    &["clean", "validate", "compile", "test", "package", "verify", "install", "site", "deploy"];
@@ -81,9 +70,6 @@ pub struct MavenModel {
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct MavenProject {
-    /// Owning project folder when displayed in a workspace.
-    #[specta(optional)]
-    pub project_root: Option<String>,
    /// Project-relative, `/`-separated (`pom.xml`, `core/pom.xml`).
    pub pom: String,
    /// Project-relative directory; `""` = the project root.
@@ -182,9 +168,6 @@ pub enum Omission {
 #[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
 #[serde(rename_all = "camelCase")]
 pub struct MavenProfile {
-    /// Owning project folder when displayed in a workspace.
-    #[specta(optional)]
-    pub project_root: Option<String>,
    pub id: String,
    pub active_by_default: bool,
 }
@@ -484,50 +467,15 @@ struct Resolver {
 }

 /// `~/.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) = xml::read_text(settings).as_deref().and_then(xml::parse) 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, ..Default::default() });
-    }
-    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> {
-    let text = xml::read_text(settings)?;
+    let text = std::fs::read_to_string(settings).ok()?;
    let root = xml::parse(&text)?;
    let repo = root.text_of("localRepository")?.trim().to_owned();
    if repo.is_empty() {
@@ -553,7 +501,7 @@ impl Resolver {
    fn pom(&mut self, path: &Path) -> Option<RawPom> {
        self.poms
            .entry(path.to_path_buf())
-            .or_insert_with(|| xml::read_text(path).as_deref().and_then(parse_pom))
+            .or_insert_with(|| std::fs::read_to_string(path).ok().and_then(|t| parse_pom(&t)))
            .clone()
    }

@@ -744,7 +692,7 @@ pub(crate) fn launch_inputs(
                return None;
            }
            out.push(path.clone());
-            let text = xml::read_text(&path)?;
+            let text = std::fs::read_to_string(&path).ok()?;
            roots(&xml::parse(&text)?, "", &dir, &mut out)?;
            let raw = resolver.pom(&path)?;
            let Some(parent) = raw.parent else { break };
@@ -1030,7 +978,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('\\', "/")
@@ -1041,7 +992,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).
@@ -1077,9 +1065,10 @@ 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.profiles(&[]), &settings.linked_projects)
+/// [`load`] with the chosen `profiles` (`-P` entries; `!id` deactivates): their modules,
+/// dependencies and properties are part of the model, those turned off are not.
+pub fn load_with_profiles(root: &Path, profiles: &[String]) -> MavenModel {
+    load_with(root, default_local_repo(), profiles)
 }

 pub(crate) fn load_with_repo(root: &Path, local_repo: Option<PathBuf>) -> MavenModel {
@@ -1101,53 +1090,11 @@ fn profile_choice(chosen: &[String], id: &str) -> Option<bool> {
 }

 pub(crate) fn load_with(root: &Path, local_repo: Option<PathBuf>, profiles: &[String]) -> MavenModel {
-    load_with_linked(root, local_repo, profiles, &[])
-}
-
-/// The POMs of `linked` (project-relative, from Settings) that exist inside `root`.
-fn linked_poms(root: &Path, linked: &[String]) -> Vec<PathBuf> {
-    let base = dunce::canonicalize(root).unwrap_or_else(|_| root.to_path_buf());
-    let mut out: Vec<PathBuf> = Vec::new();
-    for pom in linked {
-        let pom = normalized_pom(pom);
-        if pom.is_empty() || pom.starts_with("../") || pom == ".." {
-            continue;
-        }
-        let path = root.join(&pom);
-        let inside = dunce::canonicalize(&path).is_ok_and(|p| p.starts_with(&base));
-        if path.is_file() && inside && !out.contains(&path) {
-            out.push(path);
-        }
-    }
-    out
-}
-
-/// Whether `root` holds a Maven build or the settings link one inside it.
-pub fn has_projects(root: &Path, settings: &ide_core::settings::MavenSettings) -> bool {
-    is_maven_project(root) || !linked_poms(root, &settings.linked_projects).is_empty()
-}
-
-/// The model with the chosen `profiles` (`-P` entries; `!id` deactivates: their modules,
-/// dependencies and properties are part of the model, those turned off are not) and the
-/// `linked` POMs (Add Maven Projects): builds that no reactor lists, shown as independent
-/// top-level projects. A linked POM that turns out to be a module of the root reactor stays that module.
-pub fn load_with_linked(
-    root: &Path,
-    local_repo: Option<PathBuf>,
-    profiles: &[String],
-    linked: &[String],
-) -> MavenModel {
    let mut resolver = Resolver::new(local_repo, profiles);
    let mut model = MavenModel::default();
    let mut seen: HashSet<PathBuf> = HashSet::new();
-    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;
@@ -1228,12 +1175,11 @@ pub fn load_with_linked(
        // The project can activate the profiles of its own POM and its ancestors'.
        for (id, active) in &ctx.profiles {
            if !model.profiles.iter().any(|x| x.id == *id) {
-                model.profiles.push(MavenProfile { id: id.clone(), active_by_default: *active, ..Default::default() });
+                model.profiles.push(MavenProfile { id: id.clone(), active_by_default: *active });
            }
        }
        let artifact_id = i(&pom.artifact_id);
        model.projects.push(MavenProject {
-            project_root: None,
            pom: rel_path(root, &path),
            dir: rel_path(root, &dir),
            group_id: i(props.get("project.groupId").map(String::as_str).unwrap_or_default()),
@@ -1270,7 +1216,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 {
@@ -1510,296 +1456,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 Some(next) = xml::read_text(&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);
@@ -1835,37 +1495,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, ..Default::default() };
-        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();
@@ -2104,49 +1733,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();
@@ -2305,24 +1891,6 @@ mod tests {
        assert!(!is_maven_project(&root.join("c")));
    }

-    #[test]
-    fn non_utf8_pom_with_declared_encoding_is_a_build() {
-        // Issue #2439: a GBK `pom.xml` is not valid UTF-8; it must still load
-        // instead of vanishing as "No maven project".
-        let tmp = tempfile::tempdir().unwrap();
-        let root = tmp.path();
-        let (bytes, _, _) = encoding_rs::GBK.encode(
-            "<?xml version=\"1.0\" encoding=\"GBK\"?>\n<project><groupId>g</groupId>\
-             <artifactId>应用</artifactId><version>1</version><name>演示</name></project>",
-        );
-        std::fs::write(root.join("pom.xml"), bytes.as_ref()).unwrap();
-        let model = load_with_repo(root, None);
-        assert_eq!(model.projects.len(), 1);
-        assert_eq!(model.projects[0].artifact_id, "应用");
-        assert_eq!(model.projects[0].display_name, "演示");
-        assert!(is_maven_project(root));
-    }
-
    #[test]
    fn aggregate_pom_in_src_is_a_build() {
        // Issue #1001: `src/pom.xml` aggregating modules under `src/` is recognized,
@@ -2497,325 +2065,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)]
@@ -1,124 +0,0 @@
-//! On-demand sources resolution using the project's Maven launcher and repositories.
-
-use super::MavenProject;
-use crate::process;
-use ide_core::{CancellationToken, IdeError, IdeResult};
-use std::path::{Component, Path, PathBuf};
-
-#[derive(Debug, PartialEq, Eq)]
-pub struct Artifact {
-    pub group: String,
-    pub name: String,
-    pub version: String,
-    pub sources: PathBuf,
-}
-
-/// Resolve only jars inside the selected local repository, including custom repositories.
-pub fn artifact(jar: &Path, repository: &Path) -> Option<Artifact> {
-    let relative = jar.strip_prefix(repository).ok()?;
-    let parts: Vec<&str> = relative
-        .components()
-        .map(|c| match c {
-            Component::Normal(s) => s.to_str(),
-            _ => None,
-        })
-        .collect::<Option<_>>()?;
-    if parts.len() < 4 {
-        return None;
-    }
-    let n = parts.len();
-    let (name, version, file) = (parts[n - 3], parts[n - 2], parts[n - 1]);
-    let valid = |s: &str| {
-        !s.is_empty() && s != "." && s != ".." && s.chars().all(|c| c.is_ascii_alphanumeric() || "_.-".contains(c))
-    };
-    if !parts[..n - 1].iter().all(|s| valid(s)) || file != format!("{name}-{version}.jar") {
-        return None;
-    }
-    Some(Artifact {
-        group: parts[..n - 3].join("."),
-        name: name.into(),
-        version: version.into(),
-        sources: jar.with_file_name(format!("{name}-{version}-sources.jar")),
-    })
-}
-
-pub fn download(
-    root: &Path,
-    project: &MavenProject,
-    artifact: &Artifact,
-    repository: &Path,
-    cancel: &CancellationToken,
-) -> IdeResult<Option<PathBuf>> {
-    if cancel.is_cancelled() {
-        return Err(IdeError::cancelled());
-    }
-    if artifact.sources.is_file() {
-        return Ok(Some(artifact.sources.clone()));
-    }
-    let mut args = vec!["-B".into(), "-N".into(), "-Dstyle.color=never".into()];
-    args.extend(project.options.clone());
-    args.extend([
-        format!("-Dmaven.repo.local={}", repository.display()),
-        "org.apache.maven.plugins:maven-dependency-plugin:3.8.1:get".into(),
-        format!("-Dartifact={}:{}:{}:jar:sources", artifact.group, artifact.name, artifact.version),
-        "-Dtransitive=false".into(),
-    ]);
-    let output = process::run(&project.command, &args, &root.join(&project.dir), &project.env, cancel, |_, _| {})?;
-    if cancel.is_cancelled() {
-        return Err(IdeError::cancelled());
-    }
-    if artifact.sources.is_file() {
-        return Ok(Some(artifact.sources.clone()));
-    }
-    let coordinate = format!("{}:{}:jar:sources:{}", artifact.group, artifact.name, artifact.version);
-    if output.success
-        || output.text.lines().any(|line| {
-            line.contains(&coordinate) && (line.contains("Could not find artifact") || line.contains("was not found"))
-        })
-    {
-        return Ok(None);
-    }
-    Err(IdeError::unavailable(
-        output.text.lines().rev().take(20).collect::<Vec<_>>().into_iter().rev().collect::<Vec<_>>().join("\n"),
-    ))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn resolves_sources_coordinates_from_maven_layouts() {
-        for repository in ["/home/me/.m2/repository", "/tmp/project repo", "C:/Users/me/.m2/repository"] {
-            for (group, name, version) in [
-                ("org/apache/commons", "commons-lang3", "3.17.0"),
-                ("com/example", "example-lib", "1.0-SNAPSHOT"),
-                ("single", "lib", "1.0.0-rc.1"),
-            ] {
-                let repository = Path::new(repository);
-                let dir = repository.join(group).join(name).join(version);
-                let found = artifact(&dir.join(format!("{name}-{version}.jar")), repository).unwrap();
-                assert_eq!(found.group, group.replace('/', "."));
-                assert_eq!(found.name, name);
-                assert_eq!(found.version, version);
-                assert_eq!(found.sources, dir.join(format!("{name}-{version}-sources.jar")));
-            }
-        }
-    }
-
-    #[test]
-    fn rejects_non_artifacts_and_paths_outside_the_repository() {
-        let repository = Path::new("/m2/repository");
-        for path in [
-            "/m2/repository-other/g/a/1/a-1.jar",
-            "/m2/repository/g/a/1/a-1-sources.jar",
-            "/m2/repository/g/a/1/other.jar",
-            "/m2/repository/g/a/../a-1.jar",
-            "/m2/repository/g/a/1/a-1.pom",
-            "/m2/repository/g/a-1.jar",
-            "/gradle/caches/modules-2/files-2.1/g/a/1/hash/a-1.jar",
-        ] {
-            assert_eq!(artifact(Path::new(path), repository), None, "{path}");
-        }
-    }
-}
@@ -73,9 +73,6 @@ struct GradleCache {
    /// The projects as Gradle evaluated them; empty in caches from before they were read.
    #[serde(default)]
    projects: Vec<ReportedProject>,
-    /// The projects report how their resources are processed; older caches are stale.
-    #[serde(default)]
-    resources: bool,
 }

 /// Init script printing every project, its source sets and Java version once configured.
@@ -98,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";

@@ -247,12 +226,11 @@ pub fn apply_gradle_cache(root: &Path, cache_dir: &Path, model: &mut GradleModel
            }
        }
    }
-    // A successful sync from before projects were cached has not seen computed includes,
-    // nor, before resources were read, which launches need Gradle to process them.
-    let outdated = cache.error.is_none() && (cache.projects.is_empty() || !cache.resources);
+    // A successful sync from before projects were cached has not seen computed includes.
+    let without_projects = cache.error.is_none() && cache.projects.is_empty();
    model.synced_at = Some(cache.at_ms);
    model.sync_error = cache.error;
-    model.stale = outdated || cache.hash != hash_gradle_files(&gradle::build_files(root, model));
+    model.stale = without_projects || cache.hash != hash_gradle_files(&gradle::build_files(root, model));
 }

 // ---------------------------------------------------------------- processes
@@ -305,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.maven_settings.profiles(&options.profiles),
-        &options.maven_settings.linked_projects,
-    );
+    let mut model = maven::load_with_profiles(root, &options.profiles);
    maven::UnlinkedProjects::from_model(&model, &options.maven_settings).filter(&mut model);
    std::fs::create_dir_all(cache_dir)?;
    let mut cache = MavenCache {
@@ -342,17 +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(),
-            maven::LOCAL_REPO_TRACKING_ARG.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());
        }
@@ -406,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![
@@ -439,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);
@@ -466,130 +403,14 @@ pub fn sync_gradle_model(
        error: (!out.success).then(|| error_summary(&out.text)),
        tasks: if out.success { gradle::parse_tasks(&out.text) } else { Vec::new() },
        projects,
-        resources: true,
    };
-    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() {
@@ -718,7 +539,6 @@ mod tests {
            test,
            src: src.iter().map(|p| core_src(p)).collect(),
            res: res.iter().map(|p| core_src(p)).collect(),
-            processed: None,
        };
        // A settings script's own println comes first; task listing lines follow.
        let out = format!(
@@ -743,15 +563,6 @@ mod tests {
        );
        let projects = parse_reported_projects(&out);
        assert_eq!(projects.len(), 3, "the malformed line is skipped");
-        // As the init script prints a set whose resources Gradle filters or renames.
-        let processed = parse_reported_projects(&format!(
-            "@openidea-model\t{}",
-            r#"{"path":":","dir":"/p","sourceSets":[{"name":"main","test":false,"src":[],"res":[],"processed":{"task":"processResources","dir":"/p/build/resources/main"}}]}"#
-        ));
-        assert_eq!(
-            processed[0].source_sets[0].processed,
-            Some(gradle::ProcessedResources { task: "processResources".into(), dir: "/p/build/resources/main".into() })
-        );
        let src = |p: &str| PathBuf::from(core_src(p));
        assert_eq!(
            gradle::reported_source_roots(&projects),
@@ -787,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();
@@ -817,18 +628,12 @@ mod tests {
                    ..Default::default()
                })
                .collect(),
-            resources: true,
        };
        write_cache(&cache_dir, GRADLE_CACHE, &cache).unwrap();
        apply_gradle_cache(&root, &cache_dir, &mut model);
        assert_eq!(model.projects[1].tasks.len(), 1);
        assert!(model.projects[0].tasks.iter().any(|t| t.name == "wrapper"), "root keeps its defaults");
        assert!(!model.stale);
-        write_cache(&cache_dir, GRADLE_CACHE, &GradleCache { resources: false, ..cache.clone() }).unwrap();
-        let mut m = gradle::load(&root).unwrap();
-        apply_gradle_cache(&root, &cache_dir, &mut m);
-        assert!(m.stale, "synced before resource processing was read");
-        write_cache(&cache_dir, GRADLE_CACHE, &cache).unwrap();

        let stale_after = |script: &str| {
            std::fs::write(root.join("app/build.gradle"), script).unwrap();
@@ -845,41 +650,6 @@ mod tests {
        assert!(m.stale, "gradle.properties is watched");
    }

-    #[test]
-    fn applied_script_edits_invalidate_the_cached_gradle_model() {
-        let tmp = tempfile::tempdir().unwrap();
-        let root = tmp.path().join("project");
-        let cache_dir = tmp.path().join("cache");
-        std::fs::create_dir_all(root.join("gradle")).unwrap();
-        std::fs::write(root.join("build.gradle"), "apply from: 'gradle/dependencies.gradle'").unwrap();
-        let applied = root.join("gradle/dependencies.gradle");
-        std::fs::write(&applied, "implementation 'g:a:1'").unwrap();
-        let model = gradle::load(&root).unwrap();
-        let cache = GradleCache {
-            hash: hash_gradle_files(&gradle::build_files(&root, &model)),
-            projects: vec![ReportedProject {
-                path: ":".into(),
-                dir: root.to_string_lossy().into_owned(),
-                ..Default::default()
-            }],
-            resources: true,
-            ..Default::default()
-        };
-        write_cache(&cache_dir, GRADLE_CACHE, &cache).unwrap();
-        let stale = || {
-            let mut model = gradle::load(&root).unwrap();
-            apply_gradle_cache(&root, &cache_dir, &mut model);
-            model.stale
-        };
-        assert!(!stale());
-        std::fs::write(&applied, "// comment\nimplementation   'g:a:1'\n").unwrap();
-        assert!(!stale());
-        std::fs::write(&applied, "implementation 'g:a:2'").unwrap();
-        assert!(stale());
-        std::fs::remove_file(&applied).unwrap();
-        assert!(stale());
-    }
-
    #[test]
    fn sync_reads_verbose_trees_with_a_pinned_plugin_unless_offline() {
        let online = maven_sync_goals(Path::new("e.xml"), false);
@@ -910,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() {
@@ -3,57 +3,6 @@
 //! skipped. Namespace prefixes are dropped (`<x:project>` → `project`).
 //! Elements keep their byte offsets in the source, for edits ([`crate::pom_edit`]).

-use encoding_rs::Encoding;
-use std::path::Path;
-
-/// Reads an XML file, honoring its `encoding="…"` declaration: a GBK POM
-/// (issue #2439) is not valid UTF-8, and `read_to_string` would drop the
-/// whole project as "No maven project" while CLI Maven reads it fine.
-pub fn read_text(path: &Path) -> Option<String> {
-    std::fs::read(path).ok().map(|bytes| decode_bytes(&bytes))
-}
-
-/// Decodes XML bytes: BOM first, then the `encoding` declaration (ASCII in
-/// every single-byte encoding, so the head scans before decoding), then
-/// UTF-8, then a chardetng guess.
-pub fn decode_bytes(bytes: &[u8]) -> String {
-    if let Some((enc, len)) = Encoding::for_bom(bytes) {
-        let (text, _) = enc.decode_without_bom_handling(&bytes[len..]);
-        return text.into_owned();
-    }
-    if let Some(enc) = declared_encoding(bytes) {
-        let (text, _) = enc.decode_without_bom_handling(bytes);
-        return text.into_owned();
-    }
-    if let Ok(text) = std::str::from_utf8(bytes) {
-        return text.to_owned();
-    }
-    let mut detector = chardetng::EncodingDetector::new();
-    detector.feed(bytes, true);
-    let (text, _) = detector.guess(None, true).decode_without_bom_handling(bytes);
-    text.into_owned()
-}
-
-fn declared_encoding(bytes: &[u8]) -> Option<&'static Encoding> {
-    let head = std::str::from_utf8(bytes.get(..bytes.len().min(1024))?).ok()?;
-    let mut rest = head.split("?>").next().unwrap_or(head);
-    while let Some(i) = rest.find("encoding") {
-        rest = &rest[i + "encoding".len()..];
-        let Some(value) = rest.trim_start().strip_prefix('=') else { continue };
-        let value = value.trim_start();
-        let (&quote, after) = value.as_bytes().split_first()?;
-        if quote != b'"' && quote != b'\'' {
-            continue;
-        }
-        let after = std::str::from_utf8(after).ok()?;
-        let end = after.find(quote as char)?;
-        if let Some(enc) = Encoding::for_label(after[..end].trim().as_bytes()) {
-            return Some(enc);
-        }
-    }
-    None
-}
-
 #[derive(Clone, Debug, Default, PartialEq, Eq)]
 pub struct Element {
    pub name: String,
@@ -261,19 +210,4 @@ mod tests {
        assert!(parse("").is_none());
        assert!(parse("just text").is_none());
    }
-
-    #[test]
-    fn decodes_the_declared_encoding() {
-        // Issue #2439: a GBK POM is not valid UTF-8; decoding must honor the declaration.
-        let (bytes, _, _) =
-            encoding_rs::GBK.encode("<?xml version=\"1.0\" encoding=\"GBK\"?>\n<project><name>中文</name></project>");
-        let text = decode_bytes(&bytes);
-        assert_eq!(parse(&text).unwrap().text_of("name").as_deref(), Some("中文"));
-        // An unknown label falls back to UTF-8 rather than mis-decoding.
-        let text = decode_bytes(b"<?xml version=\"1.0\" encoding=\"X-UNKNOWN\"?>\n<project><name>ok</name></project>");
-        assert_eq!(parse(&text).unwrap().text_of("name").as_deref(), Some("ok"));
-        // No declaration: plain UTF-8 passes through untouched.
-        let text = decode_bytes("<project><name>plain</name></project>".as_bytes());
-        assert_eq!(parse(&text).unwrap().text_of("name").as_deref(), Some("plain"));
-    }
 }
@@ -1,20 +0,0 @@
-[package]
-name = "ide-cli"
-description = "The `openidea` command: arguments, the request it sends a running app over a local socket, and installing it on PATH"
-version.workspace = true
-edition.workspace = true
-license.workspace = true
-
-[dependencies]
-serde.workspace = true
-serde_json.workspace = true
-dirs.workspace = true
-tracing.workspace = true
-
-[target.'cfg(windows)'.dependencies]
-tokio = { workspace = true, features = ["net"] }
-winreg = "0.56"
-windows-sys = { version = "0.61", features = ["Win32_Foundation", "Win32_Storage_FileSystem", "Win32_System_Console", "Win32_UI_WindowsAndMessaging"] }
-
-[dev-dependencies]
-tempfile.workspace = true
@@ -1,234 +0,0 @@
-//! Command-line arguments of `openidea`.
-
-use crate::Target;
-use std::path::Path;
-
-pub const USAGE: &str = "\
-Usage: openidea [options] [[--line <n>] [--column <n>] path[:line[:column]] ...]
-       openidea diff <left> <right>
-
-Opens folders as projects and files in the editor of the running OpenIDEA,
-starting it if needed. Without paths, brings OpenIDEA to the front.
-Lines and columns start at 1; --line and --column apply to the next path.
-
-Options:
-  --line <n>     Put the caret on line <n> of the next file
-  --column <n>   Put the caret in column <n> of that line
-  -h, --help     Show this help
-  -v, --version  Show the version
-";
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum Command {
-    Help,
-    Version,
-    Open(Vec<Target>),
-    Diff(Vec<Target>),
-}
-
-/// Parses `args` (without the program name); relative paths resolve against `cwd`.
-pub fn parse(args: &[String], cwd: &Path) -> Result<Command, String> {
-    parse_with(args, cwd, &|p| p.exists())
-}
-
-fn parse_with(args: &[String], cwd: &Path, exists: &dyn Fn(&Path) -> bool) -> Result<Command, String> {
-    if args.first().is_some_and(|arg| arg == "diff") {
-        return match parse_paths(&args[1..], cwd, exists)? {
-            Command::Open(targets) if targets.len() == 2 => Ok(Command::Diff(targets)),
-            Command::Help => Ok(Command::Help),
-            _ => Err("diff needs two files".into()),
-        };
-    }
-    parse_paths(args, cwd, exists)
-}
-
-fn parse_paths(args: &[String], cwd: &Path, exists: &dyn Fn(&Path) -> bool) -> Result<Command, String> {
-    let mut targets = Vec::new();
-    let mut options = true;
-    let (mut line, mut column) = (None, None);
-    let mut args = args.iter();
-    while let Some(arg) = args.next() {
-        let (flag, inline) = match arg.split_once('=') {
-            Some((flag, value)) if options && flag.starts_with("--") => (flag, Some(value.to_owned())),
-            _ => (arg.as_str(), None),
-        };
-        match flag {
-            "--" if options => options = false,
-            "-h" | "--help" if options => return Ok(Command::Help),
-            "-v" | "--version" if options => return Ok(Command::Version),
-            "--line" | "--column" if options => {
-                let value = inline.or_else(|| args.next().cloned()).ok_or(format!("{flag} needs a number"))?;
-                let n = position(&value).ok_or(format!("{flag}: not a number from 1: {value}"))?;
-                *if flag == "--line" { &mut line } else { &mut column } = Some(n);
-            }
-            a if options && a.starts_with('-') && a != "-" => return Err(format!("unknown option: {a}")),
-            _ => {
-                let mut target = target(arg, cwd, exists)?;
-                if line.is_some() || column.is_some() {
-                    target.line = line.take().or(target.line).or(Some(1));
-                    target.column = column.take();
-                }
-                targets.push(target);
-            }
-        }
-    }
-    if line.is_some() || column.is_some() {
-        return Err("--line and --column need a file after them".into());
-    }
-    Ok(Command::Open(targets))
-}
-
-/// `arg` as a path, else as `path:line[:column]` when `path` exists.
-fn target(arg: &str, cwd: &Path, exists: &dyn Fn(&Path) -> bool) -> Result<Target, String> {
-    let path = cwd.join(arg);
-    if exists(&path) {
-        return Ok(Target { path, line: None, column: None });
-    }
-    for (base, line, column) in split_position(arg) {
-        let path = cwd.join(base);
-        if exists(&path) {
-            return Ok(Target { path, line: Some(line), column });
-        }
-    }
-    Err(format!("{arg}: no such file or directory"))
-}
-
-/// The readings of `arg` as `path:line:column`, then as `path:line`.
-fn split_position(arg: &str) -> Vec<(&str, u32, Option<u32>)> {
-    let Some((rest, last)) = arg.rsplit_once(':') else { return Vec::new() };
-    let Some(last) = position(last) else { return Vec::new() };
-    let mut readings = Vec::new();
-    if let Some((base, line)) = rest.rsplit_once(':')
-        && let Some(line) = position(line)
-        && !base.is_empty()
-    {
-        readings.push((base, line, Some(last)));
-    }
-    if !rest.is_empty() {
-        readings.push((rest, last, None));
-    }
-    readings
-}
-
-fn position(s: &str) -> Option<u32> {
-    if s.is_empty() || !s.bytes().all(|b| b.is_ascii_digit()) {
-        return None;
-    }
-    s.parse().ok().filter(|n| *n > 0)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::path::PathBuf;
-
-    fn args(list: &[&str]) -> Vec<String> {
-        list.iter().map(|s| (*s).to_owned()).collect()
-    }
-
-    fn parse_in(list: &[&str], existing: &[&str]) -> Result<Command, String> {
-        let existing: Vec<PathBuf> = existing.iter().map(PathBuf::from).collect();
-        parse_with(&args(list), Path::new("/work"), &|p| existing.iter().any(|e| e == p))
-    }
-
-    fn at(path: &str, line: Option<u32>, column: Option<u32>) -> Target {
-        Target { path: path.into(), line, column }
-    }
-
-    #[test]
-    fn paths_resolve_against_cwd() {
-        assert_eq!(
-            parse_in(&["src", "/abs/a.rs"], &["/work/src", "/abs/a.rs"]),
-            Ok(Command::Open(vec![at("/work/src", None, None), at("/abs/a.rs", None, None)]))
-        );
-        assert_eq!(parse_in(&[], &[]), Ok(Command::Open(vec![])));
-    }
-
-    #[test]
-    fn positions_split_only_when_the_whole_arg_is_missing() {
-        let files = ["/work/a.rs"];
-        assert_eq!(parse_in(&["a.rs:12"], &files), Ok(Command::Open(vec![at("/work/a.rs", Some(12), None)])));
-        assert_eq!(parse_in(&["a.rs:12:5"], &files), Ok(Command::Open(vec![at("/work/a.rs", Some(12), Some(5))])));
-        assert!(parse_in(&["a.rs:0"], &files).is_err());
-        assert!(parse_in(&["a.rs:x"], &files).is_err());
-        assert!(parse_in(&["missing.rs:3"], &files).is_err());
-    }
-
-    // Windows file names cannot contain `:`, and `b:2` reads as a path on drive B.
-    #[cfg(unix)]
-    #[test]
-    fn an_existing_name_with_a_colon_wins_over_a_position() {
-        let files = ["/work/b:2"];
-        assert_eq!(parse_in(&["b:2"], &files), Ok(Command::Open(vec![at("/work/b:2", None, None)])));
-        assert_eq!(parse_in(&["b:2:7"], &files), Ok(Command::Open(vec![at("/work/b:2", Some(7), None)])));
-    }
-
-    #[test]
-    fn windows_drive_colon_is_not_a_position() {
-        assert_eq!(split_position(r"C:\a.rs:10"), vec![(r"C:\a.rs", 10, None)]);
-        assert_eq!(split_position(r"C:\a.rs:10:2"), vec![(r"C:\a.rs", 10, Some(2)), (r"C:\a.rs:10", 2, None)]);
-        assert!(split_position(r"C:\a.rs").is_empty());
-    }
-
-    #[cfg(windows)]
-    #[test]
-    fn windows_absolute_and_unc_targets_keep_spaces_and_unicode() {
-        let local = PathBuf::from(r"C:\项目\my file.rs");
-        let network = PathBuf::from(r"\\server\share\folder name");
-        let command = parse_with(
-            &args(&[r"C:\项目\my file.rs:12:5", r"\\server\share\folder name"]),
-            Path::new(r"D:\work"),
-            &|path| path == local || path == network,
-        );
-        assert_eq!(
-            command,
-            Ok(Command::Open(vec![
-                Target { path: local, line: Some(12), column: Some(5) },
-                Target { path: network, line: None, column: None },
-            ]))
-        );
-    }
-
-    #[test]
-    fn line_and_column_flags_apply_to_the_next_path() {
-        let files = ["/work/a.rs", "/work/b.rs"];
-        assert_eq!(
-            parse_in(&["--line", "12", "--column=5", "a.rs", "b.rs"], &files),
-            Ok(Command::Open(vec![at("/work/a.rs", Some(12), Some(5)), at("/work/b.rs", None, None)]))
-        );
-        assert_eq!(
-            parse_in(&["--line=3", "a.rs:9:9"], &files),
-            Ok(Command::Open(vec![at("/work/a.rs", Some(3), None)]))
-        );
-        assert!(parse_in(&["--line", "0", "a.rs"], &files).is_err());
-        assert!(parse_in(&["--line"], &files).is_err());
-        assert!(parse_in(&["a.rs", "--line", "2"], &files).is_err());
-    }
-
-    #[test]
-    fn options() {
-        assert_eq!(parse_in(&["-h"], &[]), Ok(Command::Help));
-        assert_eq!(parse_in(&["--version"], &[]), Ok(Command::Version));
-        assert!(parse_in(&["--nope"], &[]).is_err());
-        assert_eq!(parse_in(&["--", "-h"], &["/work/-h"]), Ok(Command::Open(vec![at("/work/-h", None, None)])));
-    }
-
-    #[test]
-    fn existing_diff_command_is_supported() {
-        let files = ["/work/a.rs", "/work/b.rs"];
-        assert_eq!(
-            parse_in(&["diff", "a.rs", "b.rs"], &files),
-            Ok(Command::Diff(vec![at("/work/a.rs", None, None), at("/work/b.rs", None, None),]))
-        );
-        assert!(parse_in(&["diff", "a.rs"], &files).is_err());
-        assert_eq!(
-            parse_in(&["diff", "diff", "b.rs"], &["/work/diff", "/work/b.rs"]),
-            Ok(Command::Diff(vec![at("/work/diff", None, None), at("/work/b.rs", None, None),]))
-        );
-        assert_eq!(parse_in(&["--", "diff"], &["/work/diff"]), Ok(Command::Open(vec![at("/work/diff", None, None)])));
-        assert_eq!(
-            parse_in(&["--column=4", "a.rs", "b.rs"], &files),
-            Ok(Command::Open(vec![at("/work/a.rs", Some(1), Some(4)), at("/work/b.rs", None, None),]))
-        );
-    }
-}
@@ -1,476 +0,0 @@
-//! Installing the `openidea` command: a symlink on `PATH` to the launcher
-//! script in a macOS bundle, or a wrapper in a user's bin directory.
-
-use std::ffi::OsStr;
-use std::io;
-use std::path::{Path, PathBuf};
-
-pub const COMMAND: &str = "openidea";
-const LAUNCHER: &str = "Contents/Resources/bin/openidea";
-const SYSTEM_DIR: &str = "/usr/local/bin";
-
-/// The launcher script of the bundle whose executable is `exe`; `None` outside a bundle.
-pub fn bundled_launcher(exe: &Path) -> Option<PathBuf> {
-    let launcher = exe.parent()?.parent()?.parent()?.join(LAUNCHER);
-    launcher.is_file().then_some(launcher)
-}
-
-/// macOS runs a quarantined app from a random read-only copy until it is moved:
-/// a link there would break on the next launch.
-pub fn translocated(path: &Path) -> bool {
-    path.to_string_lossy().contains("/AppTranslocation/")
-}
-
-/// Where the link goes: `~/.local/bin` when it is on `path_var` (no administrator
-/// rights needed), else `/usr/local/bin`.
-pub fn link_dir(path_var: Option<&OsStr>, home: Option<&Path>) -> PathBuf {
-    let local = home.map(|h| h.join(".local/bin"));
-    match (path_var, local) {
-        (Some(var), Some(local)) if std::env::split_paths(var).any(|p| p == local) => local,
-        _ => PathBuf::from(SYSTEM_DIR),
-    }
-}
-
-/// Directories an earlier install may have used.
-pub fn link_dirs(home: Option<&Path>) -> Vec<PathBuf> {
-    home.map(|h| h.join(".local/bin")).into_iter().chain([PathBuf::from(SYSTEM_DIR)]).collect()
-}
-
-/// The installed links among `dirs` (any OpenIDEA bundle's launcher).
-pub fn installed(dirs: &[PathBuf]) -> Vec<PathBuf> {
-    dirs.iter().map(|d| d.join(COMMAND)).filter(|l| is_launcher_link(l)).collect()
-}
-
-fn is_launcher_link(link: &Path) -> bool {
-    std::fs::read_link(link).is_ok_and(|target| target.ends_with(LAUNCHER))
-}
-
-/// Links `dir/openidea` to `launcher`, asking for administrator rights when `dir`
-/// is not writable. Refuses to replace an `openidea` that is not ours.
-pub fn install(launcher: &Path, dir: &Path) -> io::Result<PathBuf> {
-    let link = dir.join(COMMAND);
-    if link.symlink_metadata().is_ok() && !is_launcher_link(&link) {
-        return Err(io::Error::new(
-            io::ErrorKind::AlreadyExists,
-            format!("{} already exists and is not an OpenIDEA command", link.display()),
-        ));
-    }
-    let direct = std::fs::create_dir_all(dir).and_then(|()| {
-        if link.symlink_metadata().is_ok() {
-            std::fs::remove_file(&link)?;
-        }
-        symlink(launcher, &link)
-    });
-    match direct {
-        Err(e) if e.kind() == io::ErrorKind::PermissionDenied => {
-            privileged(&format!("mkdir -p {} && ln -sfn {} {}", quote(dir), quote(launcher), quote(&link)))?
-        }
-        result => result?,
-    }
-    Ok(link)
-}
-
-/// Removes `links`, asking for administrator rights where needed.
-pub fn uninstall(links: &[PathBuf]) -> io::Result<()> {
-    for link in links {
-        match std::fs::remove_file(link) {
-            Err(e) if e.kind() == io::ErrorKind::PermissionDenied => privileged(&format!("rm -f {}", quote(link)))?,
-            result => result?,
-        }
-    }
-    Ok(())
-}
-
-#[cfg(unix)]
-fn symlink(target: &Path, link: &Path) -> io::Result<()> {
-    std::os::unix::fs::symlink(target, link)
-}
-
-#[cfg(not(unix))]
-fn symlink(_target: &Path, _link: &Path) -> io::Result<()> {
-    Err(io::Error::new(io::ErrorKind::Unsupported, "not supported on this platform"))
-}
-
-/// Runs `command` as root after the system's password prompt. Cancelling it is
-/// [`io::ErrorKind::Interrupted`].
-fn privileged(command: &str) -> io::Result<()> {
-    if !cfg!(target_os = "macos") {
-        return Err(io::Error::new(io::ErrorKind::PermissionDenied, "administrator rights required"));
-    }
-    let script = format!("do shell script \"{}\" with administrator privileges", applescript_escape(command));
-    let output = std::process::Command::new("/usr/bin/osascript").arg("-e").arg(script).output()?;
-    if output.status.success() {
-        return Ok(());
-    }
-    let message = String::from_utf8_lossy(&output.stderr).trim().to_owned();
-    // "User canceled. (-128)"
-    let kind = if message.contains("(-128)") { io::ErrorKind::Interrupted } else { io::ErrorKind::PermissionDenied };
-    Err(io::Error::new(kind, message))
-}
-
-fn quote(path: &Path) -> String {
-    format!("'{}'", path.to_string_lossy().replace('\'', r"'\''"))
-}
-
-fn applescript_escape(s: &str) -> String {
-    s.replace('\\', r"\\").replace('"', "\\\"")
-}
-
-const WRAPPER_MARKER: &str = "OpenIDEA command launcher v1";
-
-/// AppImages remount their executable on every launch. Keep the original image path.
-pub fn stable_executable(exe: &Path, appimage: Option<&Path>) -> io::Result<PathBuf> {
-    let path = appimage.unwrap_or(exe);
-    if !path.is_absolute() || !path.is_file() {
-        return Err(io::Error::new(io::ErrorKind::NotFound, "the OpenIDEA executable must be in a permanent location"));
-    }
-    Ok(path.to_path_buf())
-}
-
-pub fn wrapper_path(dir: &Path, windows: bool) -> PathBuf {
-    dir.join(if windows { "openidea.cmd" } else { COMMAND })
-}
-
-fn wrapper(exe: &Path, windows: bool) -> io::Result<String> {
-    let exe =
-        exe.to_str().ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "the executable path is not UTF-8"))?;
-    if exe.contains(['\r', '\n']) || (windows && exe.contains('"')) {
-        return Err(io::Error::new(io::ErrorKind::InvalidInput, "the executable path contains unsupported characters"));
-    }
-    Ok(if windows {
-        format!(
-            "@echo off\r\nrem {WRAPPER_MARKER}\r\nsetlocal DisableDelayedExpansion\r\nfor /f \"tokens=2 delims=:\" %%c in ('\"%SystemRoot%\\System32\\chcp.com\"') do set \"_openidea_codepage=%%c\"\r\n\"%SystemRoot%\\System32\\chcp.com\" 65001 >nul\r\n\"{}\" --cli %*\r\nset \"_openidea_exit=%errorlevel%\"\r\n\"%SystemRoot%\\System32\\chcp.com\" %_openidea_codepage% >nul\r\nexit /b %_openidea_exit%\r\n",
-            exe.replace('%', "%%")
-        )
-    } else {
-        format!("#!/bin/sh\n# {WRAPPER_MARKER}\nexec {} --cli \"$@\"\n", quote(Path::new(exe)))
-    })
-}
-
-pub fn is_wrapper(path: &Path, windows: bool) -> bool {
-    path.symlink_metadata().is_ok_and(|meta| meta.is_file() && !meta.file_type().is_symlink())
-        && std::fs::read_to_string(path).is_ok_and(|text| {
-            text.lines().nth(1) == Some(&format!("{} {WRAPPER_MARKER}", if windows { "rem" } else { "#" }))
-        })
-}
-
-/// Never follows or overwrites a foreign file, even if it has the same command name.
-pub fn install_wrapper(exe: &Path, dir: &Path, windows: bool) -> io::Result<PathBuf> {
-    use std::io::Write;
-    let text = wrapper(exe, windows)?;
-    let path = wrapper_path(dir, windows);
-    if path.symlink_metadata().is_ok() {
-        if !is_wrapper(&path, windows) {
-            return Err(io::Error::new(
-                io::ErrorKind::AlreadyExists,
-                format!("{} already exists and is not an OpenIDEA command", path.display()),
-            ));
-        }
-        std::fs::remove_file(&path)?;
-    }
-    std::fs::create_dir_all(dir)?;
-    let mut file = std::fs::OpenOptions::new().write(true).create_new(true).open(&path)?;
-    #[cfg(unix)]
-    {
-        use std::os::unix::fs::PermissionsExt;
-        file.set_permissions(std::fs::Permissions::from_mode(0o755))?;
-    }
-    file.write_all(text.as_bytes())?;
-    Ok(path)
-}
-
-pub fn uninstall_wrapper(dir: &Path, windows: bool) -> io::Result<Vec<PathBuf>> {
-    let path = wrapper_path(dir, windows);
-    if !is_wrapper(&path, windows) {
-        return Ok(vec![]);
-    }
-    std::fs::remove_file(&path)?;
-    Ok(vec![path])
-}
-
-/// Preserve every unrelated PATH entry, including expandable environment variables.
-pub fn windows_path(current: &str, dir: &str, add: bool) -> Option<String> {
-    fn equal(a: &str, b: &str) -> bool {
-        a.trim().trim_matches('"').trim_end_matches(['\\', '/']).eq_ignore_ascii_case(b.trim_end_matches(['\\', '/']))
-    }
-    let found = current.split(';').any(|entry| equal(entry, dir));
-    if add {
-        if found {
-            return None;
-        }
-        Some(format!("{dir}{}{current}", if current.is_empty() { "" } else { ";" }))
-    } else if found {
-        Some(current.split(';').filter(|entry| !equal(entry, dir)).collect::<Vec<_>>().join(";"))
-    } else {
-        None
-    }
-}
-
-#[cfg(windows)]
-pub fn update_user_path(dir: &Path, add: bool) -> io::Result<()> {
-    use winreg::{
-        RegKey,
-        enums::{HKEY_CURRENT_USER, REG_EXPAND_SZ},
-        types::{FromRegValue, ToRegValue},
-    };
-    let (environment, _) = RegKey::predef(HKEY_CURRENT_USER).create_subkey("Environment")?;
-    let raw = match environment.get_raw_value("Path") {
-        Ok(raw) => Some(raw),
-        Err(e) if e.kind() == io::ErrorKind::NotFound => None,
-        Err(e) => return Err(e),
-    };
-    let current = raw.as_ref().map(String::from_reg_value).transpose()?.unwrap_or_default();
-    let Some(updated) = windows_path(&current, &dir.to_string_lossy(), add) else { return Ok(()) };
-    let mut value = updated.to_reg_value();
-    value.vtype = raw.as_ref().map_or(REG_EXPAND_SZ, |raw| raw.vtype.clone());
-    environment.set_raw_value("Path", &value)?;
-    let message: Vec<u16> = "Environment\0".encode_utf16().collect();
-    // SAFETY: the terminated string stays alive for this bounded synchronous broadcast.
-    unsafe {
-        windows_sys::Win32::UI::WindowsAndMessaging::SendMessageTimeoutW(
-            windows_sys::Win32::UI::WindowsAndMessaging::HWND_BROADCAST,
-            windows_sys::Win32::UI::WindowsAndMessaging::WM_SETTINGCHANGE,
-            0,
-            message.as_ptr() as isize,
-            windows_sys::Win32::UI::WindowsAndMessaging::SMTO_ABORTIFHUNG,
-            1000,
-            std::ptr::null_mut(),
-        );
-    }
-    Ok(())
-}
-
-pub struct Installation {
-    pub path: PathBuf,
-    /// Some when the user needs to add this directory to their shell's PATH.
-    pub path_directory: Option<PathBuf>,
-}
-
-fn resolves_to(path_var: Option<&OsStr>, command: &Path) -> bool {
-    path_var
-        .and_then(|path| std::env::split_paths(path).map(|dir| dir.join(COMMAND)).find(|candidate| candidate.is_file()))
-        .is_some_and(|candidate| candidate == command)
-}
-
-fn user_bin() -> io::Result<PathBuf> {
-    if cfg!(windows) {
-        dirs::data_local_dir().map(|dir| dir.join("OpenIDEA/bin"))
-    } else {
-        dirs::home_dir().map(|dir| dir.join(".local/bin"))
-    }
-    .ok_or_else(|| io::Error::new(io::ErrorKind::NotFound, "no user directory for the openidea command"))
-}
-
-pub fn install_current() -> io::Result<Installation> {
-    let exe = std::env::current_exe()?;
-    if cfg!(target_os = "macos") {
-        let launcher = bundled_launcher(&exe).ok_or_else(|| {
-            io::Error::new(io::ErrorKind::NotFound, "install the command from the packaged OpenIDEA app")
-        })?;
-        if translocated(&launcher) {
-            return Err(io::Error::new(
-                io::ErrorKind::PermissionDenied,
-                "move OpenIDEA to the Applications folder first",
-            ));
-        }
-        let dir = link_dir(std::env::var_os("PATH").as_deref(), dirs::home_dir().as_deref());
-        return Ok(Installation { path: install(&launcher, &dir)?, path_directory: None });
-    }
-    let image = if cfg!(target_os = "linux") { std::env::var_os("APPIMAGE").map(PathBuf::from) } else { None };
-    let exe = stable_executable(&exe, image.as_deref())?;
-    let dir = user_bin()?;
-    let path = install_wrapper(&exe, &dir, cfg!(windows))?;
-    #[cfg(windows)]
-    update_user_path(&dir, true)?;
-    let on_path = cfg!(windows) || resolves_to(std::env::var_os("PATH").as_deref(), &path);
-    Ok(Installation { path, path_directory: (!on_path).then_some(dir) })
-}
-
-pub fn uninstall_current() -> io::Result<Vec<PathBuf>> {
-    if cfg!(target_os = "macos") {
-        let links = installed(&link_dirs(dirs::home_dir().as_deref()));
-        uninstall(&links)?;
-        return Ok(links);
-    }
-    let dir = user_bin()?;
-    let path = wrapper_path(&dir, cfg!(windows));
-    if is_wrapper(&path, cfg!(windows)) {
-        #[cfg(windows)]
-        update_user_path(&dir, false)?;
-        return uninstall_wrapper(&dir, cfg!(windows));
-    }
-    Ok(vec![])
-}
-
-#[cfg(test)]
-mod wrapper_tests {
-    use super::*;
-
-    #[test]
-    fn wrappers_install_update_and_remove_only_their_own_files() {
-        for windows in [false, true] {
-            let dir = tempfile::tempdir().unwrap();
-            let exe = dir.path().join("App folder/程序 & it's 100%.exe");
-            let path = install_wrapper(&exe, dir.path(), windows).unwrap();
-            assert!(is_wrapper(&path, windows));
-            assert_eq!(install_wrapper(&exe, dir.path(), windows).unwrap(), path);
-            assert_eq!(uninstall_wrapper(dir.path(), windows).unwrap(), vec![path.clone()]);
-            assert!(uninstall_wrapper(dir.path(), windows).unwrap().is_empty());
-            std::fs::write(&path, "foreign command").unwrap();
-            assert_eq!(install_wrapper(&exe, dir.path(), windows).unwrap_err().kind(), io::ErrorKind::AlreadyExists);
-            assert!(uninstall_wrapper(dir.path(), windows).unwrap().is_empty());
-            assert_eq!(std::fs::read_to_string(&path).unwrap(), "foreign command");
-        }
-    }
-
-    #[test]
-    fn path_changes_keep_other_entries_and_do_not_duplicate_the_command_dir() {
-        let dir = r"C:\Users\用户\OpenIDEA\bin";
-        let initial = r"%USERPROFILE%\tools;C:\other";
-        let updated = windows_path(initial, dir, true).unwrap();
-        assert_eq!(updated, format!("{dir};{initial}"));
-        assert_eq!(windows_path(&updated, dir, true), None);
-        assert_eq!(windows_path(&updated, dir, false).as_deref(), Some(initial));
-        assert_eq!(
-            windows_path(&format!("\"{dir}\\\";C:\\other"), &dir.to_uppercase(), false).as_deref(),
-            Some(r"C:\other")
-        );
-        assert_eq!(windows_path(initial, dir, false), None);
-    }
-
-    #[test]
-    fn appimage_uses_the_persistent_image_not_the_mounted_binary() {
-        let dir = tempfile::tempdir().unwrap();
-        let image = dir.path().join("OpenIDEA.AppImage");
-        std::fs::write(&image, "image").unwrap();
-        assert_eq!(stable_executable(Path::new("/tmp/.mount_App/usr/bin/openidea"), Some(&image)).unwrap(), image);
-        assert_eq!(stable_executable(&image, None).unwrap(), image);
-        assert!(stable_executable(Path::new("missing"), None).is_err());
-    }
-
-    #[test]
-    fn detects_a_system_binary_shadowing_the_linux_wrapper() {
-        let dir = tempfile::tempdir().unwrap();
-        let system = dir.path().join("system");
-        let user = dir.path().join("user");
-        for bin in [&system, &user] {
-            std::fs::create_dir_all(bin).unwrap();
-            std::fs::write(bin.join(COMMAND), "command").unwrap();
-        }
-        let path = std::env::join_paths([&system, &user]).unwrap();
-        assert!(!resolves_to(Some(&path), &user.join(COMMAND)));
-        let path = std::env::join_paths([&user, &system]).unwrap();
-        assert!(resolves_to(Some(&path), &user.join(COMMAND)));
-    }
-
-    #[cfg(unix)]
-    #[test]
-    fn posix_wrapper_preserves_arguments_and_exit_status() {
-        use std::os::unix::fs::PermissionsExt;
-        let dir = tempfile::tempdir().unwrap();
-        let exe = dir.path().join("app & it's $dollar `quoted` \"double\"");
-        std::fs::write(&exe, "#!/bin/sh\nprintf '%s\\n' \"$@\"\nexit 7\n").unwrap();
-        std::fs::set_permissions(&exe, std::fs::Permissions::from_mode(0o755)).unwrap();
-        let path = install_wrapper(&exe, &dir.path().join("bin"), false).unwrap();
-        let output = std::process::Command::new(path).args(["a b", "中文", "x'$`&"]).output().unwrap();
-        assert_eq!(output.status.code(), Some(7));
-        assert_eq!(String::from_utf8(output.stdout).unwrap(), "--cli\na b\n中文\nx'$`&\n");
-    }
-
-    #[cfg(windows)]
-    #[test]
-    fn cmd_wrapper_preserves_arguments_and_exit_status() {
-        use std::os::windows::process::CommandExt;
-        let dir = tempfile::tempdir().unwrap();
-        let exe = dir.path().join("程序 & 100% !special!.exe");
-        let source = dir.path().join("helper.rs");
-        std::fs::write(
-            &source,
-            r#"fn main() { for arg in std::env::args().skip(1) { println!("{arg}"); } std::process::exit(7); }"#,
-        )
-        .unwrap();
-        let compiled = std::process::Command::new("rustc")
-            .args(["--crate-name", "launcher_test"])
-            .arg(&source)
-            .arg("-o")
-            .arg(&exe)
-            .output()
-            .unwrap();
-        assert!(compiled.status.success(), "{}", String::from_utf8_lossy(&compiled.stderr));
-        let path = install_wrapper(&exe, &dir.path().join("bin"), true).unwrap();
-        std::fs::write(dir.path().join("chcp.cmd"), "@echo malicious-chcp\r\nexit /b 99\r\n").unwrap();
-        let output = std::process::Command::new("cmd.exe")
-            .current_dir(dir.path())
-            .args(["/d", "/s", "/c"])
-            .raw_arg(format!("\"\"{}\" \"a b\" \"中文\" \"x&y\"\"", path.display()))
-            .output()
-            .unwrap();
-        assert_eq!(output.status.code(), Some(7));
-        assert_eq!(String::from_utf8(output.stdout).unwrap().replace("\r\n", "\n"), "--cli\na b\n中文\nx&y\n");
-        let check = dir.path().join("check.cmd");
-        std::fs::write(&check, "@echo off\r\nfor /f \"tokens=2 delims=:\" %%c in ('\"%SystemRoot%\\System32\\chcp.com\"') do set \"before=%%c\"\r\ncall \"%~dp0bin\\openidea.cmd\" example\r\nset \"code=%errorlevel%\"\r\nfor /f \"tokens=2 delims=:\" %%c in ('\"%SystemRoot%\\System32\\chcp.com\"') do set \"after=%%c\"\r\nif not \"%before%\"==\"%after%\" exit /b 99\r\nexit /b %code%\r\n").unwrap();
-        let output = std::process::Command::new("cmd.exe")
-            .current_dir(dir.path())
-            .args(["/d", "/s", "/c"])
-            .raw_arg(format!("\"\"{}\"\"", check.display()))
-            .output()
-            .unwrap();
-        assert_eq!(output.status.code(), Some(7));
-        assert!(!String::from_utf8_lossy(&output.stdout).contains("malicious-chcp"));
-    }
-}
-
-#[cfg(all(test, unix))]
-mod tests {
-    use super::*;
-
-    fn bundle(root: &Path) -> (PathBuf, PathBuf) {
-        let app = root.join("OpenIDEA.app");
-        let exe = app.join("Contents/MacOS/openidea");
-        let launcher = app.join(LAUNCHER);
-        std::fs::create_dir_all(exe.parent().unwrap()).unwrap();
-        std::fs::create_dir_all(launcher.parent().unwrap()).unwrap();
-        std::fs::write(&exe, "").unwrap();
-        std::fs::write(&launcher, "").unwrap();
-        (exe, launcher)
-    }
-
-    #[test]
-    fn finds_the_launcher_of_a_bundle_only() {
-        let dir = tempfile::tempdir().unwrap();
-        let (exe, launcher) = bundle(dir.path());
-        assert_eq!(bundled_launcher(&exe), Some(launcher));
-        assert_eq!(bundled_launcher(&dir.path().join("target/debug/openidea")), None);
-        assert!(translocated(Path::new("/private/var/folders/x/AppTranslocation/ABC/d/OpenIDEA.app")));
-    }
-
-    #[test]
-    fn prefers_local_bin_on_path() {
-        let home = Path::new("/Users/u");
-        let path = std::env::join_paths(["/usr/bin", "/Users/u/.local/bin"]).unwrap();
-        assert_eq!(link_dir(Some(&path), Some(home)), home.join(".local/bin"));
-        assert_eq!(link_dir(Some(OsStr::new("/usr/bin")), Some(home)), PathBuf::from(SYSTEM_DIR));
-        assert_eq!(link_dir(None, Some(home)), PathBuf::from(SYSTEM_DIR));
-    }
-
-    #[test]
-    fn install_replaces_its_own_link_but_not_other_files() {
-        let dir = tempfile::tempdir().unwrap();
-        let (_, launcher) = bundle(dir.path());
-        let bin = dir.path().join("bin");
-        let link = install(&launcher, &bin).unwrap();
-        assert_eq!(std::fs::read_link(&link).unwrap(), launcher);
-        assert_eq!(install(&launcher, &bin).unwrap(), link);
-        assert_eq!(installed(std::slice::from_ref(&bin)), vec![link.clone()]);
-        uninstall(&installed(std::slice::from_ref(&bin))).unwrap();
-        assert!(installed(std::slice::from_ref(&bin)).is_empty());
-        std::fs::write(&link, "someone else's").unwrap();
-        assert_eq!(install(&launcher, &bin).unwrap_err().kind(), io::ErrorKind::AlreadyExists);
-    }
-
-    #[test]
-    fn quoting() {
-        assert_eq!(quote(Path::new("/a b/it's")), r"'/a b/it'\''s'");
-        assert_eq!(applescript_escape(r#"ln "a\b""#), r#"ln \"a\\b\""#);
-    }
-}
@@ -1,72 +0,0 @@
-//! The `openidea` command.
-//!
-//! The command is the app's own executable run in CLI mode: it parses its
-//! arguments ([`args`]), sends one [`Request`] to the running app over a local
-//! socket ([`socket`]) and exits. [`install`] links the bundle's launcher
-//! script into a directory on `PATH`.
-
-pub mod args;
-pub mod install;
-pub mod socket;
-
-use serde::{Deserialize, Serialize};
-use std::path::PathBuf;
-
-/// Bumped when [`Request`] changes incompatibly; an app still running an older
-/// version answers with an error instead of misreading it.
-pub const PROTOCOL_VERSION: u32 = 1;
-
-/// A file or folder to open, with an optional 1-based position in a file.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct Target {
-    /// Absolute.
-    pub path: PathBuf,
-    pub line: Option<u32>,
-    pub column: Option<u32>,
-}
-
-/// What the command asks the running app to do. No targets: bring the app to the front.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct Request {
-    pub version: u32,
-    pub targets: Vec<Target>,
-    #[serde(default)]
-    pub diff: bool,
-}
-
-impl Request {
-    pub fn open(targets: Vec<Target>) -> Self {
-        Self { version: PROTOCOL_VERSION, targets, diff: false }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(tag = "kind", rename_all = "camelCase")]
-pub enum Response {
-    Ok,
-    Error { message: String },
-}
-
-/// A GUI subsystem executable inherits redirected handles, but needs its parent's
-/// console for interactive help and errors. Batch launchers wait for this process.
-#[cfg(windows)]
-pub fn attach_console() {
-    use windows_sys::Win32::Storage::FileSystem::{FILE_TYPE_DISK, FILE_TYPE_PIPE, GetFileType};
-    use windows_sys::Win32::System::Console::{
-        ATTACH_PARENT_PROCESS, AttachConsole, GetStdHandle, STD_ERROR_HANDLE, STD_INPUT_HANDLE, STD_OUTPUT_HANDLE,
-        SetStdHandle,
-    };
-    // SAFETY: attaches only this CLI process, without allocating a new console.
-    unsafe {
-        let redirected = [STD_INPUT_HANDLE, STD_OUTPUT_HANDLE, STD_ERROR_HANDLE].map(|kind| {
-            let handle = GetStdHandle(kind);
-            (kind, handle, matches!(GetFileType(handle), FILE_TYPE_DISK | FILE_TYPE_PIPE))
-        });
-        AttachConsole(ATTACH_PARENT_PROCESS);
-        for (kind, handle, keep) in redirected {
-            if keep {
-                SetStdHandle(kind, handle);
-            }
-        }
-    }
-}
@@ -1,266 +0,0 @@
-//! The local socket the running app listens on: one JSON [`Request`] line in,
-//! one [`Response`] line out. Unix domain sockets or Windows named pipes.
-
-use crate::{Request, Response};
-use std::io;
-use std::path::{Path, PathBuf};
-use std::time::Duration;
-
-const TIMEOUT: Duration = Duration::from_secs(10);
-const MAX_MESSAGE: u64 = 1024 * 1024;
-
-fn answer(line: &str, handle: &dyn Fn(Request) -> Response) -> Response {
-    match serde_json::from_str::<Request>(line) {
-        Ok(request) if request.version == crate::PROTOCOL_VERSION && (!request.diff || request.targets.len() == 2) => {
-            handle(request)
-        }
-        Ok(_) => Response::Error { message: "unsupported or invalid CLI request".into() },
-        Err(e) => Response::Error { message: format!("invalid request: {e}") },
-    }
-}
-
-/// The socket of the app with bundle identifier `identifier`. The name is a hash:
-/// socket paths are limited to about 100 bytes, and development identifiers are long.
-pub fn socket_path(identifier: &str) -> Option<PathBuf> {
-    if cfg!(windows) {
-        let user = dirs::data_local_dir()?;
-        return Some(PathBuf::from(format!(
-            r"\\.\pipe\openidea-{:016x}",
-            fnv1a(&format!("{}:{identifier}", user.display()))
-        )));
-    }
-    let dir = if cfg!(target_os = "macos") { dirs::cache_dir() } else { dirs::runtime_dir().or_else(dirs::cache_dir) };
-    Some(dir?.join(format!("openidea-{:016x}.sock", fnv1a(identifier))))
-}
-
-fn fnv1a(s: &str) -> u64 {
-    s.bytes().fold(0xcbf29ce484222325, |hash, byte| (hash ^ u64::from(byte)).wrapping_mul(0x100000001b3))
-}
-
-#[cfg(unix)]
-mod imp {
-    use super::*;
-    use std::io::{BufRead, BufReader, Read, Write};
-    use std::os::unix::fs::{FileTypeExt, PermissionsExt};
-    use std::os::unix::net::{UnixListener, UnixStream};
-
-    pub fn send(socket: &Path, request: &Request) -> io::Result<Response> {
-        let stream = UnixStream::connect(socket)?;
-        stream.set_read_timeout(Some(TIMEOUT))?;
-        stream.set_write_timeout(Some(TIMEOUT))?;
-        write_line(&stream, request)?;
-        let mut reply = String::new();
-        BufReader::new((&stream).take(MAX_MESSAGE)).read_line(&mut reply)?;
-        Ok(serde_json::from_str(&reply)?)
-    }
-
-    pub fn serve(socket: &Path, handle: impl Fn(Request) -> Response + Send + 'static) -> io::Result<()> {
-        let listener = bind(socket)?;
-        std::thread::Builder::new().name("cli-socket".into()).spawn(move || {
-            for stream in listener.incoming().flatten() {
-                if let Err(e) = serve_one(&stream, &handle) {
-                    tracing::warn!("cli request failed: {e}");
-                }
-            }
-        })?;
-        Ok(())
-    }
-
-    /// Binds `socket`, replacing a stale file no one answers on.
-    fn bind(socket: &Path) -> io::Result<UnixListener> {
-        if let Some(dir) = socket.parent() {
-            std::fs::create_dir_all(dir)?;
-        }
-        let listener = match UnixListener::bind(socket) {
-            Err(e) if e.kind() == io::ErrorKind::AddrInUse => {
-                if !std::fs::symlink_metadata(socket)?.file_type().is_socket() || UnixStream::connect(socket).is_ok() {
-                    return Err(e);
-                }
-                std::fs::remove_file(socket)?;
-                UnixListener::bind(socket)?
-            }
-            bound => bound?,
-        };
-        std::fs::set_permissions(socket, std::fs::Permissions::from_mode(0o600))?;
-        Ok(listener)
-    }
-
-    fn serve_one(stream: &UnixStream, handle: &dyn Fn(Request) -> Response) -> io::Result<()> {
-        stream.set_read_timeout(Some(TIMEOUT))?;
-        stream.set_write_timeout(Some(TIMEOUT))?;
-        let mut line = String::new();
-        BufReader::new(stream.take(MAX_MESSAGE)).read_line(&mut line)?;
-        write_line(stream, &answer(&line, handle))
-    }
-
-    fn write_line(mut stream: &UnixStream, value: &impl serde::Serialize) -> io::Result<()> {
-        let mut line = serde_json::to_string(value)?;
-        line.push('\n');
-        stream.write_all(line.as_bytes())
-    }
-}
-
-#[cfg(windows)]
-mod imp {
-    use super::*;
-    use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};
-    use tokio::net::windows::named_pipe::{ClientOptions, ServerOptions};
-
-    fn runtime() -> io::Result<tokio::runtime::Runtime> {
-        tokio::runtime::Builder::new_current_thread().enable_all().build()
-    }
-
-    pub fn send(socket: &Path, request: &Request) -> io::Result<Response> {
-        runtime()?.block_on(async {
-            tokio::time::timeout(TIMEOUT, async {
-                let mut pipe = loop {
-                    match ClientOptions::new().open(socket) {
-                        Ok(pipe) => break pipe,
-                        // All existing instances are busy; wait instead of starting another app.
-                        Err(e) if e.raw_os_error() == Some(231) => tokio::time::sleep(Duration::from_millis(10)).await,
-                        Err(e) => return Err(e),
-                    }
-                };
-                let mut line = serde_json::to_vec(request)?;
-                line.push(b'\n');
-                pipe.write_all(&line).await?;
-                let mut reply = String::new();
-                BufReader::new((&mut pipe).take(MAX_MESSAGE)).read_line(&mut reply).await?;
-                pipe.write_all(b"\n").await?;
-                Ok(serde_json::from_str(&reply)?)
-            })
-            .await
-            .map_err(|_| io::Error::new(io::ErrorKind::TimedOut, "CLI request timed out"))?
-        })
-    }
-
-    pub fn serve(socket: &Path, handle: impl Fn(Request) -> Response + Send + 'static) -> io::Result<()> {
-        let socket = socket.to_owned();
-        let (ready, receiver) = std::sync::mpsc::sync_channel(1);
-        std::thread::Builder::new().name("cli-pipe".into()).spawn(move || {
-            let runtime = match runtime() {
-                Ok(runtime) => runtime,
-                Err(e) => {
-                    let _ = ready.send(Err(e));
-                    return;
-                }
-            };
-            runtime.block_on(async move {
-                let mut pipe = match ServerOptions::new().first_pipe_instance(true).create(&socket) {
-                    Ok(pipe) => pipe,
-                    Err(e) => {
-                        let _ = ready.send(Err(e));
-                        return;
-                    }
-                };
-                let _ = ready.send(Ok(()));
-                loop {
-                    if let Err(e) = pipe.connect().await {
-                        tracing::warn!("CLI pipe connection failed: {e}");
-                        return;
-                    }
-                    // Keep an instance bound while answering, so another process cannot take the name.
-                    let next = match ServerOptions::new().create(&socket) {
-                        Ok(next) => next,
-                        Err(e) => {
-                            tracing::warn!("cannot create CLI pipe: {e}");
-                            return;
-                        }
-                    };
-                    let reply = tokio::time::timeout(TIMEOUT, async {
-                        let mut line = String::new();
-                        BufReader::new((&mut pipe).take(MAX_MESSAGE)).read_line(&mut line).await?;
-                        let mut reply = serde_json::to_vec(&answer(&line, &handle))?;
-                        reply.push(b'\n');
-                        pipe.write_all(&reply).await?;
-                        // Wait until the client has drained the reply before closing its instance.
-                        pipe.read_exact(&mut [0u8; 1]).await.map(|_| ())
-                    })
-                    .await;
-                    if !matches!(reply, Ok(Ok(()))) {
-                        tracing::warn!("CLI pipe request failed: {reply:?}");
-                    }
-                    // Dropping after the write lets the client drain its reply before disconnecting.
-                    drop(pipe);
-                    pipe = next;
-                }
-            });
-        })?;
-        receiver.recv().map_err(|_| io::Error::other("CLI pipe thread stopped"))?
-    }
-}
-
-/// Sends `request` to the app listening on `socket` and waits for its answer.
-pub use imp::send;
-/// Answers requests on `socket` with `handle`, on a thread of its own.
-pub use imp::serve;
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn socket_names_separate_identifiers_and_stay_short() {
-        let release = socket_path("ai.l0ng.openidea").unwrap();
-        let dev = socket_path("ai.l0ng.openidea.dev.w158e9c5954b7bf64").unwrap();
-        assert_ne!(release, dev);
-        assert!(dev.as_os_str().len() < 100 || cfg!(unix));
-    }
-
-    #[test]
-    fn answers_only_its_protocol_version() {
-        let ok = |_: Request| Response::Ok;
-        assert_eq!(answer(&serde_json::to_string(&Request::open(vec![])).unwrap(), &ok), Response::Ok);
-        let old = r#"{"version":0,"targets":[]}"#;
-        assert!(matches!(answer(old, &ok), Response::Error { .. }));
-        assert!(matches!(answer("garbage", &ok), Response::Error { .. }));
-    }
-
-    #[cfg(windows)]
-    #[test]
-    fn named_pipe_round_trip() {
-        let socket = socket_path(&format!("test-{}", std::process::id())).unwrap();
-        let (tx, rx) = std::sync::mpsc::channel();
-        serve(&socket, move |request| {
-            tx.send(request).unwrap();
-            Response::Ok
-        })
-        .unwrap();
-        for _ in 0..2 {
-            let target = crate::Target { path: r"C:\项目\my file.rs".into(), line: Some(3), column: Some(2) };
-            assert_eq!(send(&socket, &Request::open(vec![target.clone()])).unwrap(), Response::Ok);
-            assert_eq!(rx.recv_timeout(TIMEOUT).unwrap().targets, vec![target]);
-        }
-        assert!(serve(&socket, |_| Response::Ok).is_err());
-    }
-
-    #[cfg(unix)]
-    #[test]
-    fn request_round_trip_and_stale_socket() {
-        let dir = tempfile::tempdir().unwrap();
-        let socket = dir.path().join("cli.sock");
-        // A file left by an app that exited without removing it.
-        drop(std::os::unix::net::UnixListener::bind(&socket).unwrap());
-        let (tx, rx) = std::sync::mpsc::channel();
-        serve(&socket, move |request| {
-            tx.send(request).unwrap();
-            Response::Ok
-        })
-        .unwrap();
-        let target = crate::Target { path: "/p/a.rs".into(), line: Some(3), column: None };
-        assert_eq!(send(&socket, &Request::open(vec![target.clone()])).unwrap(), Response::Ok);
-        assert_eq!(rx.recv().unwrap().targets, vec![target]);
-        // A live server keeps its socket.
-        assert_eq!(serve(&socket, |_| Response::Ok).unwrap_err().kind(), io::ErrorKind::AddrInUse);
-    }
-
-    #[cfg(unix)]
-    #[test]
-    fn refuses_to_remove_an_unrelated_file() {
-        let dir = tempfile::tempdir().unwrap();
-        let socket = dir.path().join("cli.sock");
-        std::fs::write(&socket, "keep").unwrap();
-        assert!(serve(&socket, |_| Response::Ok).is_err());
-        assert_eq!(std::fs::read_to_string(&socket).unwrap(), "keep");
-    }
-}
@@ -11,6 +11,3 @@ license.workspace = true
 objc2 = { version = "0.6", default-features = false, features = ["std"] }
 objc2-foundation = { version = "0.3", default-features = false, features = ["std", "NSArray", "NSDictionary", "NSEnumerator", "NSObject", "NSString", "NSURL", "NSValue"] }
 objc2-app-kit = { version = "0.3", default-features = false, features = ["std", "NSPasteboard"] }
-
-[target.'cfg(target_os = "linux")'.dependencies]
-gtk = "0.18"
@@ -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
@@ -21,12 +21,6 @@

 use std::path::PathBuf;

-/// Replaces every clipboard flavor with plain text. `owner` is the calling window
-/// handle on Windows, ignored elsewhere. Call on the main thread on macOS and Linux.
-pub fn set_text(text: &str, owner: usize) -> std::io::Result<()> {
-    imp::set_text(text, owner)
-}
-
 /// Size of `DROPFILES`: `pFiles`, `pt` (two `LONG`s), `fNC`, `fWide`.
 const HEADER: usize = 20;

@@ -50,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> {
@@ -129,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;
@@ -171,12 +150,8 @@ mod imp {
    /// Opens the clipboard as its owner: the list is written in full, so no
    /// owning window is needed.
    fn open() -> bool {
-        open_for(ptr::null_mut())
-    }
-
-    fn open_for(owner: Handle) -> bool {
        for _ in 0..OPEN_ATTEMPTS {
-            if unsafe { OpenClipboard(owner) } != 0 {
+            if unsafe { OpenClipboard(ptr::null_mut()) } != 0 {
                return true;
            }
            std::thread::sleep(OPEN_RETRY);
@@ -240,37 +215,14 @@ mod imp {
        }
    }

-    pub fn set_text(text: &str, owner: usize) -> std::io::Result<()> {
-        let (memory, _) = global_text(text);
-        if memory.is_null() {
-            return Err(std::io::Error::last_os_error());
-        }
-        // SAFETY: ownership transfers only on success; otherwise we free the allocation.
-        unsafe {
-            if !open_for(owner as Handle) {
-                GlobalFree(memory);
-                return Err(std::io::Error::last_os_error());
-            }
-            let taken = EmptyClipboard() != 0 && !SetClipboardData(CF_UNICODETEXT, memory).is_null();
-            let error = std::io::Error::last_os_error();
-            CloseClipboard();
-            if taken {
-                Ok(())
-            } else {
-                GlobalFree(memory);
-                Err(error)
-            }
-        }
-    }
-
    pub fn set_files(paths: &[PathBuf]) -> bool {
        let bytes = encode(paths);
        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 {
@@ -290,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);
@@ -326,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>(
@@ -373,19 +323,6 @@ mod imp {
        })
    }

-    pub fn set_text(text: &str, _owner: usize) -> std::io::Result<()> {
-        debug_assert!(MainThreadMarker::new().is_some(), "NSPasteboard access requires the main thread");
-        autoreleasepool(|_| {
-            let board = NSPasteboard::generalPasteboard();
-            board.clearContents();
-            if board.setString_forType(&NSString::from_str(text), unsafe { NSPasteboardTypeString }) {
-                Ok(())
-            } else {
-                Err(std::io::Error::other("Cannot write clipboard text"))
-            }
-        })
-    }
-
    pub fn set_files(paths: &[PathBuf]) -> bool {
        debug_assert!(MainThreadMarker::new().is_some(), "NSPasteboard access requires the main thread");
        autoreleasepool(|_| {
@@ -401,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
        })
@@ -416,19 +355,6 @@ mod imp {
 mod imp {
    use std::path::PathBuf;

-    pub fn set_text(text: &str, _owner: usize) -> std::io::Result<()> {
-        #[cfg(target_os = "linux")]
-        {
-            gtk::Clipboard::get(&gtk::gdk::SELECTION_CLIPBOARD).set_text(text);
-            Ok(())
-        }
-        #[cfg(not(target_os = "linux"))]
-        {
-            let _ = text;
-            Err(std::io::Error::other("Clipboard text is unavailable on this platform"))
-        }
-    }
-
    pub fn has_files() -> bool {
        false
    }
@@ -489,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 = ["Wdk_System_SystemServices", "Win32_Foundation", "Win32_Globalization", "Win32_Security", "Win32_System_Diagnostics_ToolHelp", "Win32_System_IO", "Win32_System_JobObjects", "Win32_System_Registry", "Win32_System_SystemInformation", "Win32_System_Threading"] }
+windows-sys = { version = "0.61", features = ["Win32_Globalization", "Win32_Security", "Win32_System_Registry", "Win32_Foundation"] }
@@ -73,8 +73,6 @@ pub struct EditorAppearanceSettings {
    pub whitespace_inner: bool,
    pub whitespace_trailing: bool,
    pub indent_guides: bool,
-    /// Colour indent guides by depth (`--syn-rainbow-*`), while `indent_guides` is on.
-    pub rainbow_indent_guides: bool,
    /// Right margin and visual guides from Code Style.
    pub hard_wrap_guides: bool,
    pub intention_bulb: bool,
@@ -97,7 +95,6 @@ impl Default for EditorAppearanceSettings {
            whitespace_inner: true,
            whitespace_trailing: true,
            indent_guides: true,
-            rainbow_indent_guides: false,
            hard_wrap_guides: true,
            intention_bulb: true,
            distraction_free_width: 80,
@@ -169,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.
@@ -264,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,
 }
@@ -282,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(),
        }
    }
@@ -479,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);
-        }
-    }
-}
@@ -10,29 +10,11 @@ use serde::{Deserialize, Serialize};
 use specta::Type;
 use std::sync::Arc;

-#[derive(Clone, Debug, Serialize, Deserialize, Type)]
-#[serde(tag = "type", rename_all = "camelCase", rename_all_fields = "camelCase")]
-pub enum McpUiRequest {
-    Confirm { client: String, tool: String, subject: String, project: String, detail: Option<String> },
-    OpenFile { path: crate::IpcPath, line: Option<u32>, column: Option<u32> },
-}
-
 #[derive(Clone, Debug, Serialize, Deserialize, Type)]
 #[serde(tag = "type", rename_all = "camelCase", rename_all_fields = "camelCase")]
 pub enum IdeEvent {
-    /// Project data source settings changed; reload the Database tree.
-    DbSourcesChanged,
-    McpRequest {
-        id: u32,
-        request: McpUiRequest,
-    },
-    McpRequestClosed {
-        id: u32,
-    },
    /// 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,
@@ -42,10 +24,6 @@ pub enum IdeEvent {
        created: Vec<crate::IpcPath>,
        modified: Vec<crate::IpcPath>,
        removed: Vec<crate::IpcPath>,
-        /// Subtrees whose ignore rules changed, after the matchers were rebuilt.
-        #[serde(default)]
-        #[specta(optional)]
-        ignore_rules: Vec<crate::IpcPath>,
    },
    /// Excluded or ignored folders whose contents changed; they stay out of `FsChanged`.
    ExcludedDirsChanged {
@@ -152,12 +130,6 @@ pub enum IdeEvent {
    SettingsChanged {
        key: String,
    },
-    UpdateStatusChanged {
-        status: crate::updates::UpdateStatus,
-    },
-    UpdateAvailable {
-        update: crate::updates::UpdateInfo,
-    },
    /// The project's source / test / resource / excluded roots changed (build files
    /// changed or folders were marked); the UI re-reads them with `project_roots`.
    ProjectRootsChanged {
@@ -257,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,
    },
@@ -273,27 +242,6 @@ pub enum DebugEvent {
        change_type: String,
        message: String,
    },
-    /// The session's capabilities changed after it started: fetch them again.
-    Capabilities,
-    JvmBackend {
-        state: JvmBackendState,
-    },
-}
-
-/// The backend that reads a debugged JVM's objects (instances, fields, referrers).
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]
-pub enum JvmBackendState {
-    Ready,
-    /// Turned off for the rest of the session: the debug adapter lacks what it needs.
-    Unsupported {
-        detail: String,
-    },
-    /// The Kotlin JDWP link only forwards now; inspecting stops.
-    Degraded {
-        detail: String,
-    },
-    Closed,
 }

 /// Where backend crates publish [`IdeEvent`]s. Cheap to clone via `Arc`.
@@ -315,19 +263,3 @@ pub struct NullSink;
 impl EventSink for NullSink {
    fn emit(&self, _: IdeEvent) {}
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use serde_json::json;
-
-    #[test]
-    fn jvm_backend_events_json_shape() {
-        let degraded = DebugEvent::JvmBackend { state: JvmBackendState::Degraded { detail: "x".into() } };
-        assert_eq!(
-            serde_json::to_value(&degraded).unwrap(),
-            json!({"kind": "jvmBackend", "state": {"kind": "degraded", "detail": "x"}})
-        );
-        assert_eq!(serde_json::to_value(DebugEvent::Capabilities).unwrap(), json!({"kind": "capabilities"}));
-    }
-}
@@ -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")));
-    }
 }
@@ -1,403 +0,0 @@
-//! Bounded, ordered process input. Only the worker touches the OS writer.
-
-use std::collections::VecDeque;
-use std::io::{self, Write};
-use std::sync::{Arc, Condvar, Mutex};
-use std::thread::JoinHandle;
-#[cfg(any(not(unix), test))]
-use std::time::Duration;
-
-const MAX_BYTES: usize = 4 * 1024 * 1024;
-const MAX_WRITES: usize = 1024;
-#[cfg(any(not(unix), test))]
-const RETRY: Duration = Duration::from_millis(4);
-
-#[derive(Default)]
-struct State {
-    queue: VecDeque<Vec<u8>>,
-    bytes: usize,
-    finished: bool,
-    aborted: bool,
-    error: Option<String>,
-}
-
-/// One worker per pipe/PTY. The byte budget includes the in-flight write.
-/// Rejected writes enqueue nothing. Dropping this handle discards pending input
-/// without joining the worker; `finish` instead drains accepted input before EOF.
-pub struct InputWriter {
-    shared: Arc<(Mutex<State>, Condvar)>,
-    worker: Option<JoinHandle<()>>,
-}
-
-impl InputWriter {
-    /// On Unix, pass the readiness hook returned by `nonblocking` for this writer.
-    pub fn new(
-        name: String,
-        mut writer: Box<dyn Write + Send>,
-        #[cfg(unix)] mut wait_writable: impl FnMut() -> io::Result<()> + Send + 'static,
-        on_error: impl FnOnce(io::Error) + Send + 'static,
-    ) -> io::Result<Self> {
-        let shared = Arc::new((Mutex::new(State::default()), Condvar::new()));
-        let worker_shared = shared.clone();
-        let worker = std::thread::Builder::new().name(name).spawn(move || {
-            let (lock, wake) = &*worker_shared;
-            let result = (|| {
-                loop {
-                    let data = {
-                        let mut state = lock.lock().unwrap();
-                        while state.queue.is_empty() && !state.finished && !state.aborted {
-                            state = wake.wait(state).unwrap();
-                        }
-                        if state.aborted {
-                            return Ok(());
-                        }
-                        let Some(data) = state.queue.pop_front() else { return Ok(()) };
-                        data
-                    };
-                    let mut offset = 0;
-                    loop {
-                        if lock.lock().unwrap().aborted {
-                            return Ok(());
-                        }
-                        let flushing = offset == data.len();
-                        let result = if !flushing {
-                            writer.write(&data[offset..]).and_then(|n| {
-                                if n == 0 {
-                                    Err(io::ErrorKind::WriteZero.into())
-                                } else {
-                                    offset += n;
-                                    Ok(())
-                                }
-                            })
-                        } else {
-                            writer.flush()
-                        };
-                        match result {
-                            Ok(()) if flushing => break,
-                            Ok(()) => {}
-                            Err(e) if e.kind() == io::ErrorKind::Interrupted => continue,
-                            Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
-                                #[cfg(unix)]
-                                match wait_writable() {
-                                    Err(e) if e.kind() == io::ErrorKind::Interrupted => {}
-                                    result => result?,
-                                }
-                                #[cfg(not(unix))]
-                                {
-                                    let state = lock.lock().unwrap();
-                                    if state.aborted {
-                                        return Ok(());
-                                    }
-                                    drop(wake.wait_timeout(state, RETRY).unwrap());
-                                }
-                            }
-                            Err(e) => return Err(e),
-                        }
-                    }
-                    let len = data.len();
-                    drop(data);
-                    let mut state = lock.lock().unwrap();
-                    state.bytes = state.bytes.saturating_sub(len);
-                }
-            })();
-            if let Err(e) = result {
-                let mut state = lock.lock().unwrap();
-                if state.aborted {
-                    return;
-                }
-                state.error = Some(e.to_string());
-                state.queue.clear();
-                state.bytes = 0;
-                drop(state);
-                on_error(e);
-            }
-        })?;
-        Ok(Self { shared, worker: Some(worker) })
-    }
-
-    pub fn write(&self, data: &[u8]) -> io::Result<()> {
-        let (lock, wake) = &*self.shared;
-        let mut state = lock.lock().unwrap();
-        if let Some(error) = &state.error {
-            return Err(io::Error::new(io::ErrorKind::BrokenPipe, error.clone()));
-        }
-        if state.finished || state.aborted {
-            return Err(io::Error::new(io::ErrorKind::BrokenPipe, "stdin is closed"));
-        }
-        if data.is_empty() {
-            return Ok(());
-        }
-        if data.len() > MAX_BYTES.saturating_sub(state.bytes) || state.queue.len() >= MAX_WRITES {
-            return Err(io::Error::new(
-                io::ErrorKind::WouldBlock,
-                "Input queue is full (4 MiB or 1024 writes); input was not sent.",
-            ));
-        }
-        state.bytes += data.len();
-        state.queue.push_back(data.to_vec());
-        wake.notify_one();
-        Ok(())
-    }
-
-    /// Send EOF after the accepted writes, without waiting for the child to read.
-    pub fn finish(&self) {
-        let (lock, wake) = &*self.shared;
-        lock.lock().unwrap().finished = true;
-        wake.notify_one();
-    }
-
-    pub fn close(&self) {
-        let (lock, wake) = &*self.shared;
-        let mut state = lock.lock().unwrap();
-        state.aborted = true;
-        state.queue.clear();
-        wake.notify_one();
-    }
-}
-
-impl Drop for InputWriter {
-    fn drop(&mut self) {
-        self.close();
-        let Some(worker) = self.worker.take() else { return };
-        #[cfg(windows)]
-        {
-            use std::os::windows::io::AsRawHandle;
-            // A cancellation can race with entry into WriteFile, so retry off
-            // the caller's thread until the worker observes the closed queue.
-            let _ = std::thread::Builder::new().name("openidea-input-cancel".into()).spawn(move || {
-                while !worker.is_finished() {
-                    unsafe {
-                        windows_sys::Win32::System::IO::CancelSynchronousIo(worker.as_raw_handle());
-                    }
-                    std::thread::sleep(RETRY);
-                }
-                let _ = worker.join();
-            });
-        }
-        #[cfg(not(windows))]
-        drop(worker);
-    }
-}
-
-/// Make a writer nonblocking and return its readiness hook. PTY clones share file
-/// status flags, so readers must also handle WouldBlock.
-#[cfg(unix)]
-pub fn nonblocking(fd: std::os::fd::RawFd) -> io::Result<impl FnMut() -> io::Result<()> + Send> {
-    let wait = readiness(fd, libc::POLLOUT)?;
-    let flags = unsafe { libc::fcntl(fd, libc::F_GETFL) };
-    if flags == -1 || unsafe { libc::fcntl(fd, libc::F_SETFL, flags | libc::O_NONBLOCK) } == -1 {
-        return Err(io::Error::last_os_error());
-    }
-    Ok(wait)
-}
-
-/// Wait for output from a nonblocking PTY without delaying the child's next read.
-#[cfg(unix)]
-pub fn readable(fd: std::os::fd::RawFd) -> io::Result<impl FnMut() -> io::Result<()> + Send> {
-    readiness(fd, libc::POLLIN)
-}
-
-#[cfg(unix)]
-fn readiness(fd: std::os::fd::RawFd, events: libc::c_short) -> io::Result<impl FnMut() -> io::Result<()> + Send> {
-    use std::os::fd::{AsRawFd, FromRawFd, OwnedFd};
-
-    // Own a duplicate so the hook remains valid if the caller closes its fd.
-    let duplicate = unsafe { libc::fcntl(fd, libc::F_DUPFD_CLOEXEC, 0) };
-    if duplicate == -1 {
-        return Err(io::Error::last_os_error());
-    }
-    // SAFETY: fcntl returned a new, owned descriptor.
-    let fd = unsafe { OwnedFd::from_raw_fd(duplicate) };
-    Ok(move || {
-        let mut pollfd = libc::pollfd { fd: fd.as_raw_fd(), events, revents: 0 };
-        // Readiness wakes immediately; the timeout only bounds abort latency.
-        if unsafe { libc::poll(&mut pollfd, 1, 50) } == -1 {
-            return Err(io::Error::last_os_error());
-        }
-        if pollfd.revents & libc::POLLNVAL != 0 {
-            return Err(io::Error::from_raw_os_error(libc::EBADF));
-        }
-        Ok(())
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::sync::atomic::{AtomicBool, Ordering};
-    use std::sync::mpsc;
-    #[cfg(unix)]
-    use std::time::Instant;
-
-    struct SlowWriter {
-        ready: Arc<AtomicBool>,
-        output: Arc<Mutex<Vec<u8>>>,
-        dropped: mpsc::Sender<()>,
-    }
-
-    impl Write for SlowWriter {
-        fn write(&mut self, bytes: &[u8]) -> io::Result<usize> {
-            if !self.ready.load(Ordering::Acquire) {
-                return Err(io::ErrorKind::WouldBlock.into());
-            }
-            let n = bytes.len().min(7);
-            self.output.lock().unwrap().extend_from_slice(&bytes[..n]);
-            Ok(n)
-        }
-
-        fn flush(&mut self) -> io::Result<()> {
-            Ok(())
-        }
-    }
-
-    impl Drop for SlowWriter {
-        fn drop(&mut self) {
-            let _ = self.dropped.send(());
-        }
-    }
-
-    #[test]
-    fn bounds_include_inflight_bytes_and_reject_whole_writes() {
-        let ready = Arc::new(AtomicBool::new(false));
-        let output = Arc::new(Mutex::new(Vec::new()));
-        let (tx, rx) = mpsc::channel();
-        let writer = InputWriter::new(
-            "test-input".into(),
-            Box::new(SlowWriter { ready: ready.clone(), output: output.clone(), dropped: tx }),
-            #[cfg(unix)]
-            || {
-                std::thread::sleep(RETRY);
-                Ok(())
-            },
-            |e| panic!("{e}"),
-        )
-        .unwrap();
-        let bytes = vec![b'x'; MAX_BYTES];
-        writer.write(&bytes).unwrap();
-        std::thread::sleep(RETRY * 2);
-        assert_eq!(writer.write(b"rejected").unwrap_err().kind(), io::ErrorKind::WouldBlock);
-        writer.close();
-        rx.recv_timeout(Duration::from_secs(1)).expect("worker stops while peer still refuses input");
-        assert!(output.lock().unwrap().is_empty());
-        assert!(writer.write(b"closed").is_err());
-        assert!(writer.shared.0.lock().unwrap().queue.is_empty());
-    }
-
-    #[test]
-    fn partial_writes_preserve_order_and_finish_drains_before_eof() {
-        let ready = Arc::new(AtomicBool::new(false));
-        let output = Arc::new(Mutex::new(Vec::new()));
-        let (tx, rx) = mpsc::channel();
-        let writer = InputWriter::new(
-            "test-input".into(),
-            Box::new(SlowWriter { ready: ready.clone(), output: output.clone(), dropped: tx }),
-            #[cfg(unix)]
-            || {
-                std::thread::sleep(RETRY);
-                Ok(())
-            },
-            |e| panic!("{e}"),
-        )
-        .unwrap();
-        let paste = "abé".repeat(1024);
-        writer.write(paste.as_bytes()).unwrap();
-        writer.write(b"tail").unwrap();
-        writer.finish();
-        assert!(writer.write(b"after EOF").is_err());
-        ready.store(true, Ordering::Release);
-        rx.recv_timeout(Duration::from_secs(1)).unwrap();
-        assert_eq!(*output.lock().unwrap(), format!("{paste}tail").as_bytes());
-    }
-
-    #[cfg(unix)]
-    #[test]
-    fn readiness_errors_are_reported_and_reject_following_writes() {
-        let (dropped, _rx) = mpsc::channel();
-        let (errors, error) = mpsc::channel();
-        let writer = InputWriter::new(
-            "test-error-input".into(),
-            Box::new(SlowWriter { ready: Arc::new(AtomicBool::new(false)), output: Arc::default(), dropped }),
-            || Err(io::Error::from_raw_os_error(libc::EBADF)),
-            move |e| errors.send(e.raw_os_error()).unwrap(),
-        )
-        .unwrap();
-        writer.write(b"input").unwrap();
-        assert_eq!(error.recv_timeout(Duration::from_secs(1)).unwrap(), Some(libc::EBADF));
-        assert_eq!(writer.write(b"later").unwrap_err().kind(), io::ErrorKind::BrokenPipe);
-        let state = writer.shared.0.lock().unwrap();
-        assert!(state.queue.is_empty());
-        assert_eq!(state.bytes, 0);
-    }
-
-    #[test]
-    fn tiny_writes_are_also_bounded() {
-        let shared = Arc::new((Mutex::new(State::default()), Condvar::new()));
-        let writer = InputWriter { shared, worker: None };
-        for _ in 0..MAX_WRITES {
-            writer.write(b"x").unwrap();
-        }
-        assert_eq!(writer.write(b"x").unwrap_err().kind(), io::ErrorKind::WouldBlock);
-    }
-
-    #[cfg(unix)]
-    #[test]
-    fn writable_input_resumes_without_timer_delays() {
-        use std::io::Read;
-        use std::os::fd::AsRawFd;
-        use std::os::unix::net::UnixStream;
-
-        let (pipe, mut peer) = UnixStream::pair().unwrap();
-        let capacity: libc::c_int = 1024;
-        // Keep the OS buffer small enough that a timer per buffer takes seconds.
-        assert_eq!(
-            unsafe {
-                libc::setsockopt(
-                    pipe.as_raw_fd(),
-                    libc::SOL_SOCKET,
-                    libc::SO_SNDBUF,
-                    (&capacity as *const libc::c_int).cast(),
-                    std::mem::size_of_val(&capacity) as libc::socklen_t,
-                )
-            },
-            0
-        );
-        peer.set_read_timeout(Some(Duration::from_secs(3))).unwrap();
-        let wait_writable = nonblocking(pipe.as_raw_fd()).unwrap();
-        let writer =
-            InputWriter::new("test-ready-input".into(), Box::new(pipe), wait_writable, |e| panic!("{e}")).unwrap();
-        let bytes = vec![b'x'; MAX_BYTES];
-        writer.write(&bytes).unwrap();
-        writer.finish();
-        // Start with a full buffer, then make the fd writable from another thread.
-        std::thread::sleep(Duration::from_millis(50));
-        let (tx, rx) = mpsc::channel();
-        let started = Instant::now();
-        let reader = std::thread::spawn(move || {
-            let mut output = Vec::new();
-            peer.read_to_end(&mut output).unwrap();
-            tx.send(output).unwrap();
-        });
-        let output = rx.recv_timeout(Duration::from_secs(1)).expect("input resumes as soon as the fd is writable");
-        assert_eq!(output, bytes);
-        reader.join().unwrap();
-        eprintln!("4 MiB input drained in {:?}", started.elapsed());
-    }
-
-    #[cfg(unix)]
-    #[test]
-    fn close_interrupts_a_full_os_pipe_while_the_peer_stays_open() {
-        use std::os::fd::AsRawFd;
-        use std::os::unix::net::UnixStream;
-        let (pipe, _peer) = UnixStream::pair().unwrap();
-        let wait_writable = nonblocking(pipe.as_raw_fd()).unwrap();
-        let mut writer =
-            InputWriter::new("test-pipe-input".into(), Box::new(pipe), wait_writable, |e| panic!("{e}")).unwrap();
-        writer.write(&vec![b'x'; MAX_BYTES]).unwrap();
-        std::thread::sleep(Duration::from_millis(50));
-        assert!(!writer.worker.as_ref().unwrap().is_finished());
-        let started = Instant::now();
-        writer.close();
-        writer.worker.take().unwrap().join().unwrap();
-        assert!(started.elapsed() < Duration::from_millis(250));
-    }
-}
@@ -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,29 +7,23 @@
 pub mod editor_settings;
 pub mod error;
 pub mod event;
-pub mod go;
 pub mod ids;
 pub mod ignored;
-pub mod input;
 pub mod inspection_settings;
 pub mod ipc_path;
 pub mod java_runtime;
 pub mod jsonc;
 pub mod output_encoding;
-pub mod platform;
 pub mod process;
 pub mod project_dir;
-pub mod project_roots;
 pub mod proxy_settings;
 pub mod remote_settings;
 pub mod settings;
 pub mod task;
 pub mod text;
 pub mod tool_path;
-pub mod updates;
 pub mod version_managers;
 pub mod workflow_settings;
-pub mod wsl;

 pub use error::{IdeError, IdeResult};
 pub use event::{EventSink, IdeEvent, NullSink, SharedSink};
@@ -21,32 +21,6 @@

 use std::collections::BTreeMap;

-/// Removes ANSI escape sequences (colour, cursor movement).
-pub fn strip_ansi(s: &str) -> String {
-    if !s.contains('\u{1b}') {
-        return s.to_owned();
-    }
-    let mut out = String::with_capacity(s.len());
-    let mut chars = s.chars().peekable();
-    while let Some(c) = chars.next() {
-        if c != '\u{1b}' {
-            out.push(c);
-            continue;
-        }
-        if chars.peek() == Some(&'[') {
-            chars.next();
-            for c in chars.by_ref() {
-                if c.is_ascii_alphabetic() || c == '~' {
-                    break;
-                }
-            }
-        } else {
-            chars.next();
-        }
-    }
-    out
-}
-
 /// Decodes complete lines or collected output from IDE-managed tools, preferring UTF-8.
 /// Windows launcher/native diagnostics fall back to the system ANSI code page.
 /// Callers must buffer incomplete lines so multibyte characters are never split.
@@ -1,29 +0,0 @@
-/// The Windows OS build used by ConPTY; unavailable on other platforms or on query failure.
-#[cfg(windows)]
-pub fn windows_build_number() -> Option<u32> {
-    use windows_sys::Wdk::System::SystemServices::RtlGetVersion;
-    use windows_sys::Win32::System::SystemInformation::OSVERSIONINFOW;
-
-    let mut info =
-        OSVERSIONINFOW { dwOSVersionInfoSize: std::mem::size_of::<OSVERSIONINFOW>() as u32, ..Default::default() };
-    // SAFETY: `info` is initialized and declares the size of the writable structure.
-    let status = unsafe { RtlGetVersion(&mut info) };
-    (status >= 0 && info.dwBuildNumber > 0).then_some(info.dwBuildNumber)
-}
-
-#[cfg(not(windows))]
-pub fn windows_build_number() -> Option<u32> {
-    None
-}
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn windows_build_is_platform_specific() {
-        let build = super::windows_build_number();
-        #[cfg(windows)]
-        assert!(build.is_some_and(|build| build > 0));
-        #[cfg(not(windows))]
-        assert_eq!(build, None);
-    }
-}
@@ -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,80 +65,19 @@ 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;
 }

-/// Whether a process with this id exists. PID reuse makes this conservative: a reused id keeps
-/// whatever was tied to the old process alive, a live process is never reported dead.
-pub fn process_alive(pid: u32) -> bool {
-    // `kill(0, 0)` would signal the caller's own process group.
-    if pid == 0 {
-        return false;
-    }
-    #[cfg(unix)]
-    {
-        // Above `i32::MAX` the id would wrap to a negative value, which `kill` reads as a group.
-        let Ok(pid) = libc::pid_t::try_from(pid) else { return false };
-        // SAFETY: signal 0 delivers nothing; it only checks that the process exists and is reachable.
-        unsafe { libc::kill(pid, 0) == 0 || std::io::Error::last_os_error().raw_os_error() == Some(libc::EPERM) }
-    }
-    #[cfg(windows)]
-    {
-        use std::os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle};
-        use windows_sys::Win32::Foundation::{ERROR_ACCESS_DENIED, GetLastError, STILL_ACTIVE};
-        use windows_sys::Win32::System::Threading::{
-            GetExitCodeProcess, OpenProcess, PROCESS_QUERY_LIMITED_INFORMATION,
-        };
-
-        // SAFETY: plain call; a non-null result is a process handle owned by this function.
-        let handle = unsafe { OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, 0, pid) };
-        if handle.is_null() {
-            // A process we may not open still exists.
-            // SAFETY: reads the thread's last error, set by the call above.
-            return unsafe { GetLastError() } == ERROR_ACCESS_DENIED;
-        }
-        // SAFETY: `handle` is valid and nobody else owns it.
-        let handle = unsafe { OwnedHandle::from_raw_handle(handle) };
-        let mut code = 0u32;
-        // SAFETY: a live process handle opened with query access; one out-parameter.
-        let ok = unsafe { GetExitCodeProcess(handle.as_raw_handle(), &mut code) };
-        // A handle that cannot be queried is not evidence that the process is gone.
-        ok == 0 || code == STILL_ACTIVE as u32
-    }
-    #[cfg(not(any(unix, windows)))]
-    {
-        true
-    }
-}
-
-/// 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)]
-pub 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
-}
-
 /// [`kill_tree`] that first asks the group to exit: `SIGTERM`, then `grace`, then `SIGKILL`.
 /// Git removes its `index.lock` on `SIGTERM`, where `SIGKILL` leaves it behind and the next
 /// git command fails. Windows has no such signal to send from outside the child's console,
@@ -169,318 +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);
-
-#[cfg(windows)]
-pub use windows_job::Job;
-#[cfg(windows)]
-pub use windows_tree::ProcessTree;
-
-/// `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);
-    // When the child started nothing, killing it alone is the whole job:
-    // `taskkill` would be a process spawn (measured at ~0.7 s here) for the
-    // same outcome, and the callers kill the child themselves.
-    if started.is_empty() {
-        return;
-    }
+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, PROCESS_TERMINATE,
-        TerminateProcess, WaitForSingleObject,
-    };
-
-    /// Owned handles to a program and its current descendants, retained even if its launcher exits.
-    pub struct ProcessTree {
-        processes: Vec<OwnedHandle>,
-    }
-
-    impl ProcessTree {
-        pub fn capture(pid: u32) -> Self {
-            let Some(root) = open_with(pid, PROCESS_TERMINATE) else { return Self { processes: Vec::new() } };
-            let children = descendants_with(pid, PROCESS_TERMINATE);
-            Self { processes: std::iter::once(root).chain(children).collect() }
-        }
-
-        pub fn is_running(&self) -> bool {
-            self.processes.iter().any(|process| {
-                // SAFETY: an owned process handle opened with SYNCHRONIZE access.
-                unsafe {
-                    WaitForSingleObject(process.as_raw_handle(), 0) == windows_sys::Win32::Foundation::WAIT_TIMEOUT
-                }
-            })
-        }
-
-        /// Requests termination children first; poll `is_running` until termination completes.
-        pub fn terminate(&self) {
-            for process in self.processes.iter().rev() {
-                // SAFETY: an owned process handle opened with TERMINATE access, never a reused pid.
-                unsafe { TerminateProcess(process.as_raw_handle(), 1) };
-            }
-        }
-    }
-
-    /// 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> {
-        descendants_with(root, 0)
-    }
-
-    fn descendants_with(root: u32, access: 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_with(pid, access) 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> {
-        open_with(pid, 0)
-    }
-
-    fn open_with(pid: u32, access: 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 | access, 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))
-    }
-}
-
-/// A kernel job object over one launched process tree. Everything a launch starts joins
-/// the job by inheritance, so [`Job::terminate`] ends the whole tree — also processes
-/// started after the launch's snapshot was taken, orphans of a launcher that already
-/// exited (where a `taskkill /T /F` from the tracked pid no longer finds them), and
-/// processes born in the window a process-enumeration kill would miss. Spawns assign
-/// their root right after it starts; when the assignment fails (an enclosing job that
-/// disallows nesting, an already-exited pid), callers fall back to `taskkill /T /F`.
-#[cfg(windows)]
-mod windows_job {
-    use std::mem::size_of;
-    use std::os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle, RawHandle};
-    use windows_sys::Win32::Foundation::{ERROR_MORE_DATA, INVALID_HANDLE_VALUE};
-    use windows_sys::Win32::System::JobObjects::{
-        AssignProcessToJobObject, CreateJobObjectW, JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE,
-        JOBOBJECT_BASIC_LIMIT_INFORMATION, JOBOBJECT_BASIC_PROCESS_ID_LIST, JOBOBJECT_EXTENDED_LIMIT_INFORMATION,
-        JobObjectBasicProcessIdList, JobObjectExtendedLimitInformation, QueryInformationJobObject,
-        SetInformationJobObject, TerminateJobObject,
-    };
-    use windows_sys::Win32::System::Threading::{IO_COUNTERS, OpenProcess, PROCESS_SET_QUOTA, PROCESS_TERMINATE};
-
-    /// A job object holding one launch's processes. The handle is kept open for the
-    /// launch's lifetime: `KILL_ON_JOB_CLOSE` ends anything still in the job when the
-    /// launch record (a run entry, a debug session) is finally dropped.
-    pub struct Job(OwnedHandle);
-
-    impl Job {
-        /// Takes the just-started `child` into a new job, so everything it starts is in
-        /// there too. `None` when the job could not be made or the process rejected the
-        /// assignment (callers fall back to `taskkill /T /F` from the child's pid).
-        pub fn for_child(child: &std::process::Child) -> Option<Job> {
-            // SAFETY: the child's own handle is a live process handle.
-            Self::from_handle(child.as_raw_handle())
-        }
-
-        /// [`Job::for_child`] for a process known by its id (a PTY child, a follow-up run,
-        /// a `tokio` child). `None` when the id no longer names an openable process — a
-        /// caller that holds the child cannot have had it reaped, so this is a dead or
-        /// already-gone launch.
-        pub fn for_pid(pid: u32) -> Option<Job> {
-            // SAFETY: plain call; a non-null result is a process handle owned by the caller.
-            // Assignment needs `SET_QUOTA | TERMINATE` on the process.
-            let handle = unsafe { OpenProcess(PROCESS_SET_QUOTA | PROCESS_TERMINATE, 0, pid) };
-            if handle.is_null() {
-                return None;
-            }
-            // SAFETY: the handle was just opened and is owned here.
-            let handle = unsafe { OwnedHandle::from_raw_handle(handle) };
-            Self::from_handle(handle.as_raw_handle())
-        }
-
-        fn from_handle(handle: RawHandle) -> Option<Job> {
-            // SAFETY: plain calls; a non-null result is a job handle owned by the caller.
-            let job = unsafe { CreateJobObjectW(std::ptr::null(), std::ptr::null()) };
-            if job.is_null() || job == INVALID_HANDLE_VALUE {
-                return None;
-            }
-            // SAFETY: the job handle is owned here and `limits` is sized as the API requires.
-            let job = unsafe { OwnedHandle::from_raw_handle(job) };
-            let mut limits = JOBOBJECT_EXTENDED_LIMIT_INFORMATION {
-                BasicLimitInformation: JOBOBJECT_BASIC_LIMIT_INFORMATION {
-                    PerProcessUserTimeLimit: 0,
-                    PerJobUserTimeLimit: 0,
-                    LimitFlags: JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE,
-                    MinimumWorkingSetSize: 0,
-                    MaximumWorkingSetSize: 0,
-                    ActiveProcessLimit: 0,
-                    Affinity: 0,
-                    PriorityClass: 0,
-                    SchedulingClass: 0,
-                },
-                IoInfo: IO_COUNTERS {
-                    ReadOperationCount: 0,
-                    WriteOperationCount: 0,
-                    OtherOperationCount: 0,
-                    ReadTransferCount: 0,
-                    WriteTransferCount: 0,
-                    OtherTransferCount: 0,
-                },
-                ProcessMemoryLimit: 0,
-                JobMemoryLimit: 0,
-                PeakProcessMemoryUsed: 0,
-                PeakJobMemoryUsed: 0,
-            };
-            // SAFETY: the job handle is owned here and `limits` is sized as the API requires.
-            let ok = unsafe {
-                SetInformationJobObject(
-                    job.as_raw_handle(),
-                    JobObjectExtendedLimitInformation,
-                    &mut limits as *mut _ as *const _,
-                    size_of::<JOBOBJECT_EXTENDED_LIMIT_INFORMATION>() as u32,
-                )
-            };
-            if ok == 0 {
-                return None;
-            }
-            // SAFETY: the process handle belongs to the just-spawned child and outlives
-            // this call; the job handle is owned here.
-            let ok = unsafe { AssignProcessToJobObject(job.as_raw_handle(), handle) };
-            if ok == 0 {
-                return None;
-            }
-            Some(Job(job))
-        }
-
-        /// Adds another just-started root of the same launch to the job (a Go build's
-        /// follow-up run, a JVM a debug session starts itself). `false` when it did not
-        /// take; the process then relies on its own kill.
-        pub fn assign_pid(&self, pid: u32) -> bool {
-            // SAFETY: plain call; the handle is opened only to assign it, and the job
-            // handle is owned and valid.
-            let handle = unsafe { OpenProcess(PROCESS_SET_QUOTA | PROCESS_TERMINATE, 0, pid) };
-            if handle.is_null() {
-                return false;
-            }
-            // SAFETY: both handles are valid for the duration of the call.
-            let ok = unsafe { AssignProcessToJobObject(self.0.as_raw_handle(), handle) };
-            // SAFETY: the process handle was opened above and is owned here.
-            unsafe { drop(OwnedHandle::from_raw_handle(handle)) };
-            ok != 0
-        }
-
-        /// Terminates every process in the job. `false` when the call failed (the job
-        /// handle is invalid): callers then fall back to `taskkill /T /F`. Termination is
-        /// asynchronous; poll [`Job::is_running`] (bounded by [`TREE_EXIT_WAIT`]) until
-        /// the tree is gone.
-        pub fn terminate(&self) -> bool {
-            // SAFETY: a job handle owned here.
-            unsafe { TerminateJobObject(self.0.as_raw_handle(), 1) != 0 }
-        }
-
-        /// Whether any process of the launch is still in the job. When the job's state
-        /// cannot be read, reports gone: waits on this must not wedge, and a kill via
-        /// [`Job::terminate`] does not depend on the answer.
-        pub fn is_running(&self) -> bool {
-            // A list of one is the common case; `ERROR_MORE_DATA` says the real list is
-            // longer, which means there are processes.
-            let mut list = JOBOBJECT_BASIC_PROCESS_ID_LIST {
-                NumberOfAssignedProcesses: 0,
-                NumberOfProcessIdsInList: 0,
-                ProcessIdList: [0],
-            };
-            let mut returned = 0u32;
-            // SAFETY: the job handle is owned here and `list` is sized as the API requires.
-            let ok = unsafe {
-                QueryInformationJobObject(
-                    self.0.as_raw_handle(),
-                    JobObjectBasicProcessIdList,
-                    &mut list as *mut _ as *mut _,
-                    size_of::<JOBOBJECT_BASIC_PROCESS_ID_LIST>() as u32,
-                    &mut returned,
-                )
-            };
-            if ok != 0 {
-                list.NumberOfProcessIdsInList > 0
-            } else {
-                std::io::Error::last_os_error().raw_os_error() == Some(ERROR_MORE_DATA as i32)
-            }
-        }
-    }
 }

 /// Gives `cmd` the host's environment back when the IDE runs from an AppImage. `AppRun` and
@@ -579,11 +213,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) =
@@ -591,12 +223,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 };
@@ -799,30 +426,6 @@ fn append_path_entries(path: &OsStr, extra: &OsStr) -> OsString {
 mod tests {
    use super::*;

-    #[test]
-    fn process_alive_tells_live_from_dead_pids() {
-        assert!(process_alive(std::process::id()));
-        assert!(!process_alive(0));
-        let mut cmd = if cfg!(windows) {
-            let mut cmd = Command::new("cmd");
-            cmd.args(["/C", "exit 0"]);
-            cmd
-        } else {
-            Command::new("true")
-        };
-        let mut child = cmd.spawn().unwrap();
-        let pid = child.id();
-        child.wait().unwrap();
-        drop(child);
-        assert!(!process_alive(pid));
-    }
-
-    #[cfg(unix)]
-    #[test]
-    fn process_alive_rejects_ids_that_are_not_a_single_process() {
-        assert!(!process_alive(u32::MAX));
-    }
-
    #[cfg(unix)]
    #[test]
    fn kill_tree_of_reaches_what_the_child_started() {
@@ -1026,7 +629,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,
@@ -1039,27 +642,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.
@@ -1143,25 +725,6 @@ mod tests {
        }
        assert_eq!(find_executable("nope", &search), None);
    }
-
-    #[cfg(unix)]
-    #[test]
-    fn process_tree_lists_the_child_of_a_shell() {
-        let mut cmd = Command::new("sh");
-        own_group(&mut cmd).args(["-c", "sleep 5 & wait"]);
-        let mut child = cmd.spawn().unwrap();
-        let sh_pid = child.id() as i32;
-        // The shell forks `sleep` after it starts, so the tree grows a moment later.
-        let deadline = std::time::Instant::now() + Duration::from_secs(2);
-        let mut tree = process_tree(sh_pid);
-        while tree.len() < 2 && std::time::Instant::now() < deadline {
-            std::thread::sleep(Duration::from_millis(20));
-            tree = process_tree(sh_pid);
-        }
-        kill_tree(&mut child);
-        assert_eq!(tree[0], sh_pid, "the pid itself comes first");
-        assert!(tree.len() >= 2 && tree[1..].iter().all(|p| *p != sh_pid), "the shell's child follows: {tree:?}");
-    }
 }

 #[cfg(all(test, unix))]
@@ -1231,66 +794,3 @@ mod kill_tests {
        assert!(started.elapsed() < Duration::from_secs(5));
    }
 }
-
-#[cfg(all(test, windows))]
-mod job_tests {
-    use super::*;
-    use std::os::windows::process::CommandExt;
-    use std::process::Stdio;
-    use std::time::Instant;
-
-    /// `cmd` that keeps a `ping` grandchild for a minute, like a launcher that started an
-    /// application: the job must reach both.
-    fn launch_tree() -> (std::process::Child, Job, ProcessTree) {
-        let mut cmd = Command::new("cmd");
-        cmd.args(["/D", "/S", "/C", "ping -n 60 127.0.0.1 >NUL"]).stdin(Stdio::null()).creation_flags(CREATE_NO_WINDOW);
-        let child = cmd.spawn().unwrap();
-        let job = Job::for_child(&child).expect("the job takes the launch");
-        let tree = ProcessTree::capture(child.id());
-        assert!(tree.is_running(), "cmd started a grandchild the job inherits");
-        (child, job, tree)
-    }
-
-    /// Termination is asynchronous: the job reports its processes gone while their
-    /// handles still wait, so wait on the handles (the reused-pid-proof oracle).
-    fn assert_gone(tree: &ProcessTree) {
-        let until = Instant::now() + Duration::from_secs(10);
-        while tree.is_running() {
-            assert!(Instant::now() < until, "the tree survived the job");
-            std::thread::sleep(Duration::from_millis(20));
-        }
-    }
-
-    #[test]
-    fn job_terminates_the_tree_the_root_started() {
-        let (mut child, job, tree) = launch_tree();
-        assert!(job.is_running());
-        assert!(job.terminate(), "TerminateJobObject succeeds");
-        // The captured tree's handles survive the root's death, so the wait below is the
-        // grandchild's, not a reused pid's.
-        assert_gone(&tree);
-        assert!(!job.is_running());
-        let _ = child.wait();
-    }
-
-    #[test]
-    fn a_later_spawned_root_joins_the_job() {
-        let (mut first, job, _) = launch_tree();
-        let mut cmd = Command::new("cmd");
-        cmd.args(["/D", "/S", "/C", "ping -n 60 127.0.0.1 >NUL"]).stdin(Stdio::null()).creation_flags(CREATE_NO_WINDOW);
-        let mut second = cmd.spawn().unwrap();
-        let second_tree = ProcessTree::capture(second.id());
-        assert!(job.assign_pid(second.id()), "the follow-up run joins the job");
-        assert!(job.terminate());
-        assert_gone(&second_tree);
-        let _ = first.wait();
-        let _ = second.wait();
-    }
-
-    #[test]
-    fn a_dead_pid_makes_no_job() {
-        // An id of a process this test cannot open (or that does not exist) gives no job,
-        // which is the callers' cue for the `taskkill /T /F` fallback.
-        assert!(Job::for_pid(u32::MAX).is_none());
-    }
-}
@@ -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,79 +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,
-}
-
-/// A plugin-owned argv wrapper for project runs (API 1.4).
-#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub struct PluginRunTarget {
-    pub id: String,
-    pub name: String,
-    pub program: String,
-    pub args: Vec<String>,
-    pub workdir_args: Vec<String>,
-    pub container_root: Option<String>,
-    pub commands: Vec<PluginCommandOverride>,
-}
-
-/// Per-command argv prefix and optional replacement working-directory arguments.
-#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub struct PluginCommandOverride {
-    pub name: String,
-    pub args: Vec<String>,
-    /// None inherits the target's list; Some([]) suppresses it.
-    #[serde(default)]
-    pub workdir_args: Option<Vec<String>>,
 }

 #[cfg(test)]
@@ -233,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);
-    }
 }
@@ -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()
 }

@@ -1,151 +0,0 @@
-use serde::{Deserialize, Serialize};
-use specta::Type;
-use std::collections::HashSet;
-use std::time::{Duration, Instant};
-
-pub const CHECK_INTERVAL: Duration = Duration::from_secs(4 * 60 * 60);
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub enum UpdateSource {
-    #[default]
-    Github,
-    Cnb,
-}
-
-impl UpdateSource {
-    pub fn resolve(preference: &str, locale: &str, system_locale: &str) -> Self {
-        match preference {
-            "github" => return Self::Github,
-            "cnb" => return Self::Cnb,
-            _ => {}
-        }
-        let locale = locale.trim();
-        let locale = if matches!(locale, "" | "auto" | "system") { system_locale } else { locale };
-        if locale.split(['-', '_']).next().is_some_and(|base| base.eq_ignore_ascii_case("zh")) {
-            Self::Cnb
-        } else {
-            Self::Github
-        }
-    }
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub struct UpdateInfo {
-    pub version: String,
-    pub current_version: String,
-    pub notes: Option<String>,
-    pub date: Option<String>,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub struct UpdateCheck {
-    pub enabled: bool,
-    pub update: Option<UpdateInfo>,
-}
-
-#[derive(Clone, Debug, Default, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub struct UpdateStatus {
-    /// Unix milliseconds of the last successful check in this process.
-    pub last_checked: Option<f64>,
-    pub checking: bool,
-}
-
-/// One schedule and announcement history for the desktop process, independent of its windows.
-#[derive(Default)]
-pub struct UpdatePolicy {
-    attempted: Option<Instant>,
-    pub status: UpdateStatus,
-    announced: HashSet<String>,
-}
-
-impl UpdatePolicy {
-    pub fn due_in(&self, now: Instant) -> Duration {
-        self.attempted.map_or(Duration::ZERO, |at| CHECK_INTERVAL.saturating_sub(now.saturating_duration_since(at)))
-    }
-
-    pub fn begin(&mut self, now: Instant) {
-        self.attempted = Some(now);
-        self.status.checking = true;
-    }
-
-    pub fn finish(&mut self, checked_at: Option<f64>) {
-        self.status.checking = false;
-        if let Some(at) = checked_at {
-            self.status.last_checked = Some(at);
-        }
-    }
-
-    pub fn announced(&self, version: &str) -> bool {
-        self.announced.contains(version)
-    }
-
-    /// Manual checks always show their result, but also count as an announcement.
-    pub fn announce(&mut self, version: &str) -> bool {
-        self.announced.insert(version.to_owned())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn automatic_and_manual_checks_resolve_the_same_preferred_source() {
-        for (preference, locale, system, expected) in [
-            ("auto", "zh-CN", "en-US", UpdateSource::Cnb),
-            ("auto", " ZH_CN ", "en-US", UpdateSource::Cnb),
-            ("auto", "system", "zh-CN", UpdateSource::Cnb),
-            ("auto", "auto", "zh-TW", UpdateSource::Cnb),
-            ("auto", "", "zh", UpdateSource::Cnb),
-            ("auto", "en", "zh-CN", UpdateSource::Github),
-            ("github", "zh", "zh-CN", UpdateSource::Github),
-            ("cnb", "en", "en-US", UpdateSource::Cnb),
-        ] {
-            assert_eq!(UpdateSource::resolve(preference, locale, system), expected);
-        }
-    }
-
-    #[test]
-    fn checks_at_startup_and_every_four_hours_even_after_failure() {
-        let mut policy = UpdatePolicy::default();
-        let now = Instant::now();
-        assert_eq!(policy.due_in(now), Duration::ZERO);
-        policy.begin(now);
-        assert!(policy.status.checking);
-        policy.finish(None);
-        assert_eq!(policy.status.last_checked, None);
-        assert_eq!(policy.due_in(now + CHECK_INTERVAL - Duration::from_secs(1)), Duration::from_secs(1));
-        assert_eq!(policy.due_in(now + CHECK_INTERVAL), Duration::ZERO);
-        policy.begin(now + CHECK_INTERVAL);
-        policy.finish(Some(1234.0));
-        assert_eq!(policy.status.last_checked, Some(1234.0));
-        assert!(!policy.status.checking);
-        assert_eq!(policy.due_in(now + CHECK_INTERVAL), CHECK_INTERVAL);
-    }
-
-    #[test]
-    fn manual_checks_reset_the_schedule_without_losing_last_success_on_failure() {
-        let mut policy = UpdatePolicy::default();
-        let now = Instant::now();
-        policy.begin(now);
-        policy.finish(Some(1000.0));
-        policy.begin(now + Duration::from_secs(60));
-        policy.finish(None);
-        assert_eq!(policy.status.last_checked, Some(1000.0));
-        assert_eq!(policy.due_in(now + CHECK_INTERVAL), Duration::from_secs(60));
-    }
-
-    #[test]
-    fn announcements_are_per_version_across_windows_sources_and_manual_checks() {
-        let mut policy = UpdatePolicy::default();
-        assert!(policy.announce("0.1.40"));
-        assert!(!policy.announce("0.1.40"));
-        assert!(policy.announce("0.1.41"));
-        assert!(!policy.announce("0.1.40"));
-        assert!(UpdatePolicy::default().announce("0.1.40"));
-    }
-}
@@ -43,7 +43,6 @@ impl Default for VcsSettings {
 pub struct GitSettings {
    /// Show blame after the current editor line.
    pub inline_blame: bool,
-    pub show_branch_in_project_view: bool,
    /// Path to the git executable; empty = auto-detect.
    pub executable: String,
    /// Default of Update Project: `merge` | `rebase`.
@@ -75,7 +74,6 @@ impl Default for GitSettings {
    fn default() -> Self {
        Self {
            inline_blame: false,
-            show_branch_in_project_view: false,
            executable: String::new(),
            update_method: "merge".into(),
            auto_update_on_push_rejected: false,
@@ -115,15 +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>,
-    /// Double-click / Enter in the changes view: `None` follows the interface (the
-    /// Commit tool window opens the diff, Local Changes the source file).
-    ///
-    /// No `skip_serializing_if`: an unset value must still appear in
-    /// `Settings::default()`, or `SettingsStore::set` rejects the key as unknown.
-    #[specta(optional)]
-    pub double_click_opens_diff: Option<bool>,
 }

 impl Default for CommitSettings {
@@ -143,8 +132,6 @@ impl Default for CommitSettings {
            body_limit: 72,
            show_right_margin: true,
            wrap_at_margin: false,
-            disabled_plugin_checks: Vec::new(),
-            double_click_opens_diff: None,
        }
    }
 }
@@ -282,8 +269,6 @@ impl Default for PythonDebuggerSettings {
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
 #[serde(default, rename_all = "camelCase")]
 pub struct RunSettings {
-    /// Target for configurations without an explicit target. Empty = local.
-    pub default_target: String,
    pub confirm_rerun: bool,
    /// Ask before closing a Run tab whose process is still running.
    pub confirm_terminate: bool,
@@ -294,13 +279,7 @@ pub struct RunSettings {

 impl Default for RunSettings {
    fn default() -> Self {
-        Self {
-            default_target: String::new(),
-            confirm_rerun: true,
-            confirm_terminate: true,
-            show_on_start: true,
-            termination_timeout_ms: 3000,
-        }
+        Self { confirm_rerun: true, confirm_terminate: true, show_on_start: true, termination_timeout_ms: 3000 }
    }
 }

@@ -322,7 +301,6 @@ pub struct TerminalSettings {
    pub override_ide_shortcuts: bool,
    pub shell_integration: bool,
    pub highlight_hyperlinks: bool,
-    pub highlight_selection: bool,
    pub option_as_meta: bool,
    /// Escape moves focus to the editor instead of reaching the shell.
    pub escape_to_editor: bool,
@@ -355,7 +333,6 @@ impl Default for TerminalSettings {
            override_ide_shortcuts: true,
            shell_integration: true,
            highlight_hyperlinks: true,
-            highlight_selection: true,
            option_as_meta: false,
            escape_to_editor: false,
            cursor_shape: "block".into(),
@@ -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,28 +6,18 @@ edition.workspace = true
 license.workspace = true

 [dependencies]
-futures.workspace = true
 tempfile.workspace = true
 ide-core.workspace = true
 ide-language.workspace = true
 ide-jsonrpc.workspace = true
-ide-jvm-attach.workspace = true
-ide-jvm-inspect.workspace = true
-ide-jdwp.workspace = true
-ide-heap.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 specta.workspace = true
 tokio = { workspace = true, features = ["net"] }
 parking_lot.workspace = true
 memchr = "2"
-percent-encoding = "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", "test-util"] }
+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,20 +90,11 @@ 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`)")
        }
-        // GDB's own DAP interpreter, stdio transport. The DAP support it needs shipped in GDB 14
-        // (`prepare_gdb` refuses older ones with the required version in the message).
-        "gdb" => cfg(
-            "gdb",
-            &["-i", "dap"],
-            "stdio",
-            "Install GDB 14 or newer (apt install gdb, dnf install gdb, brew install gdb)",
-        ),
-        "rdbg" => cfg("rdbg", &["-O", "--port", PORT_PLACEHOLDER, "-c"], "tcp", "gem install debug"),
        // A jdtls bundle: the session is started through jdtls and reached via `debugServer`.
        "java-debug" => cfg(
            "com.microsoft.java.debug.plugin.jar",
@@ -135,7 +120,6 @@ pub fn default_type(adapter: &str) -> Option<&'static str> {
        "delve" => "go",
        "netcoredbg" => "coreclr",
        "lldb-dap" => "lldb-dap",
-        "gdb" => "gdb",
        "java-debug" => "java",
        _ => return None,
    })
@@ -175,11 +159,6 @@ pub fn parse_address(addr: &str) -> Option<(String, u16)> {
 }

 /// A port that was free a moment ago on the loopback interface.
-///
-/// Inherently racy: another process can bind the port between the listener being
-/// dropped here and the adapter binding it. Callers that hand the port to a child
-/// retry on a bind conflict (see [`ProcessLauncher`]), or — better — let the child
-/// pick `:0` and report the actual port back (as the Kotlin JDWP debuggee does).
 pub fn free_port() -> std::io::Result<u16> {
    let listener = std::net::TcpListener::bind(("127.0.0.1", 0))?;
    Ok(listener.local_addr()?.port())
@@ -211,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"]
        {
@@ -341,89 +312,6 @@ pub async fn prepare_debugpy(spec: &mut AdapterSpec) -> IdeResult<()> {
    )))
 }

-/// GDB's DAP interpreter (`-i dap`) shipped in GDB 14; older ones exit with
-/// "Interpreter `dap' unrecognized".
-const GDB_MIN_MAJOR: u32 = 14;
-
-/// `(major, minor)` of the first version number in the output of `gdb --version`
-/// (`GNU gdb (GDB) 14.2`, `GNU gdb (Ubuntu 12.1-0ubuntu1~22.04.2) 12.1`, `GNU gdb
-/// (GDB) 15.0.50.20240403-0ubuntu1`). `None` when no standalone version number is there.
-pub fn parse_gdb_version(output: &str) -> Option<(u32, u32)> {
-    let line = output.lines().next()?;
-    // Distribution names can contain versions, e.g. `(GDB; SUSE Linux Enterprise 15) 14.2`.
-    let line = line.rsplit_once(')').map_or(line, |(_, version)| version);
-    let b = line.as_bytes();
-    let mut i = 0;
-    while i < b.len() {
-        if !b[i].is_ascii_digit() {
-            i += 1;
-            continue;
-        }
-        let start = i;
-        while i < b.len() && b[i].is_ascii_digit() {
-            i += 1;
-        }
-        let major: u32 = line[start..i].parse().ok()?;
-        let mut minor = 0;
-        if i + 1 < b.len() && b[i] == b'.' && b[i + 1].is_ascii_digit() {
-            i += 1;
-            let ms = i;
-            while i < b.len() && b[i].is_ascii_digit() {
-                i += 1;
-            }
-            minor = line[ms..i].parse().unwrap_or(0);
-        }
-        // A version stands alone: `mingw32-gdb13.exe`'s embedded digits are part of a word.
-        if start > 0 && (b[start - 1].is_ascii_alphabetic() || b[start - 1] == b'_') {
-            continue;
-        }
-        return Some((major, minor));
-    }
-    None
-}
-
-/// Probe the already resolved and verified executable with its launch environment.
-async fn gdb_version(binary: &Path, spec: &AdapterSpec) -> IdeResult<Option<(u32, u32)>> {
-    let mut probe = Command::new(binary);
-    if let Some(path) = adapter_path(&spec.env) {
-        probe.env("PATH", path);
-    }
-    ide_core::process::prepare(probe.as_std_mut());
-    let probe = probe
-        .arg("--version")
-        .current_dir(&spec.cwd)
-        .envs(spec.env.iter().cloned())
-        .stdin(Stdio::null())
-        .stdout(Stdio::piped())
-        .stderr(Stdio::null())
-        .kill_on_drop(true)
-        .output();
-    let Ok(Ok(out)) = tokio::time::timeout(Duration::from_secs(15), probe).await else {
-        return Ok(None);
-    };
-    Ok(parse_gdb_version(&String::from_utf8_lossy(&out.stdout)))
-}
-
-/// Refuse old GDB versions and report whether launch must follow configurationDone.
-/// GDB 15 starts the inferior in launch; 14 and 16+ start it at configurationDone.
-async fn prepare_gdb(spec: &AdapterSpec, binary: &Path) -> IdeResult<bool> {
-    let Some((major, minor)) = gdb_version(binary, spec).await? else {
-        return Ok(false);
-    };
-    if major >= GDB_MIN_MAJOR {
-        return Ok(major == 15);
-    }
-    let mut msg = format!(
-        "debugging with GDB needs GDB {GDB_MIN_MAJOR} or newer (found {major}.{minor}): \
-         this one has no DAP interpreter (`gdb -i dap`)"
-    );
-    if let Some(hint) = &spec.install_hint {
-        msg.push_str(". ");
-        msg.push_str(hint);
-    }
-    Err(IdeError::unavailable(msg))
-}
-
 /// An adapter that is a plugin of another program (java-debug, a jdtls bundle) rather
 /// than a program: it has no process of its own and is reached through `debugServer`.
 pub fn is_plugin_bundle(command: &str) -> bool {
@@ -457,8 +345,6 @@ pub type BoxWriter = Box<dyn AsyncWrite + Unpin + Send>;

 /// A connected adapter: byte streams plus the process (if we spawned one).
 pub struct AdapterIo {
-    /// GDB 15 starts running inside `launch`; configure breakpoints before sending it.
-    pub launch_after_configuration: bool,
    pub reader: BoxReader,
    pub writer: BoxWriter,
    pub child: Option<Child>,
@@ -473,8 +359,8 @@ pub struct AdapterIo {
 pub type ProgramOutput = tokio::sync::mpsc::UnboundedReceiver<(&'static str, String)>;
 type ProgramSink = tokio::sync::mpsc::UnboundedSender<(&'static str, String)>;

-/// These debuggees inherit adapter stdio; no DAP event carries their output.
-const SHARES_STDIO: &[&str] = &["delve", "rdbg"];
+/// Delve's debuggee inherits its stdio; no DAP output event carries what the program prints.
+const SHARES_STDIO: &str = "delve";
 const DELVE_BANNER: &str = "DAP server listening at:";

 pub type LaunchFuture = Pin<Box<dyn Future<Output = IdeResult<AdapterIo>> + Send>>;
@@ -493,9 +379,6 @@ const CONNECT_TIMEOUT: Duration = Duration::from_secs(15);
 const EMBEDDED_START_TIMEOUT: Duration = Duration::from_secs(120);
 /// Probe of a `connect` address before starting the command.
 const PROBE_TIMEOUT: Duration = Duration::from_millis(500);
-/// Attempts at a fresh port for a TCP adapter: the one `free_port` hands out can be
-/// claimed by another process before the adapter binds it, so a new one usually wins.
-const PORT_ATTEMPTS: u32 = 3;

 impl AdapterLauncher for ProcessLauncher {
    fn launch(&self, mut spec: AdapterSpec, reuse_port: Option<u16>) -> LaunchFuture {
@@ -510,7 +393,6 @@ impl AdapterLauncher for ProcessLauncher {
                let stream = connect_with_retries(host, port, None, timeout).await?;
                let (r, w) = stream.into_split();
                return Ok(AdapterIo {
-                    launch_after_configuration: false,
                    reader: Box::new(r),
                    writer: Box::new(w),
                    child: None,
@@ -534,7 +416,6 @@ impl AdapterLauncher for ProcessLauncher {
                let _ = stream.set_nodelay(true);
                let (r, w) = stream.into_split();
                return Ok(AdapterIo {
-                    launch_after_configuration: false,
                    reader: Box::new(r),
                    writer: Box::new(w),
                    child: None,
@@ -563,152 +444,84 @@ impl AdapterLauncher for ProcessLauncher {
                        .ok_or_else(|| missing(&spec))?
                }
            };
-            let launch_after_configuration =
-                if spec.adapter == "gdb" { prepare_gdb(&spec, &binary).await? } else { false };
-            let base_args = substitute_root(&spec.args, &spec.cwd);
-            match spec.transport {
-                Transport::Stdio => {
-                    let mut io = spawn_adapter(&spec, &binary, &base_args, None, CONNECT_TIMEOUT).await?;
-                    io.launch_after_configuration = launch_after_configuration;
-                    Ok(io)
+            let port = match spec.transport {
+                // An embedded adapter started without `${port}` listens on its usual address.
+                Transport::Tcp => match &embedded {
+                    Some((_, port)) if !spec.args.iter().any(|a| a.contains(PORT_PLACEHOLDER)) => Some(*port),
+                    _ => Some(free_port()?),
+                },
+                Transport::Stdio => None,
+            };
+            let args = substitute_root(&spec.args, &spec.cwd);
+            let args = match port {
+                Some(port) => substitute_port(&args, port),
+                None => args,
+            };
+            let mut cmd = Command::new(&binary);
+            ide_core::process::prepare(cmd.as_std_mut());
+            cmd.args(&args)
+                .envs(spec.env.iter().map(|(k, v)| (k, v)))
+                .current_dir(&spec.cwd)
+                .stdin(if port.is_some() { Stdio::null() } else { Stdio::piped() })
+                .stdout(Stdio::piped())
+                .stderr(Stdio::piped())
+                .kill_on_drop(true);
+            let mut child =
+                cmd.spawn().map_err(|e| IdeError::unavailable(format!("failed to start {}: {e}", binary.display())))?;
+            let (program_sink, program_output) = if spec.adapter == SHARES_STDIO {
+                let (tx, rx) = tokio::sync::mpsc::unbounded_channel();
+                (Some(tx), Some(rx))
+            } else {
+                (None, None)
+            };
+            if let Some(err) = child.stderr.take() {
+                pump_lines(err, spec.adapter.clone(), stderr.clone(), program_sink.clone().map(|tx| (tx, "stderr")));
+            }
+            match port {
+                None => {
+                    let stdin = child.stdin.take().ok_or_else(|| IdeError::internal("adapter stdin unavailable"))?;
+                    let stdout = child.stdout.take().ok_or_else(|| IdeError::internal("adapter stdout unavailable"))?;
+                    Ok(AdapterIo {
+                        reader: Box::new(stdout),
+                        writer: Box::new(stdin),
+                        child: Some(child),
+                        port: None,
+                        stderr,
+                        program_output,
+                    })
                }
-                Transport::Tcp => {
-                    // An embedded adapter started without `${port}` listens on its usual
-                    // address; every other TCP adapter gets a port chosen here so it can be
-                    // retried if another process takes it before the adapter binds.
-                    let fixed = match &embedded {
-                        Some((_, port)) if !spec.args.iter().any(|a| a.contains(PORT_PLACEHOLDER)) => Some(*port),
-                        _ => None,
-                    };
-                    let start_timeout = if embedded.is_some() { EMBEDDED_START_TIMEOUT } else { CONNECT_TIMEOUT };
-                    for attempt in 1..=PORT_ATTEMPTS {
-                        let port = match fixed {
-                            Some(port) => port,
-                            None => free_port()?,
-                        };
-                        let args = substitute_port(&base_args, port);
-                        match spawn_adapter(&spec, &binary, &args, Some(port), start_timeout).await {
-                            Ok(mut io) => {
-                                io.launch_after_configuration = launch_after_configuration;
-                                return Ok(io);
-                            }
-                            Err(e) => {
-                                if fixed.is_none() && attempt < PORT_ATTEMPTS && is_port_race(&e) {
-                                    tracing::warn!(
-                                        target: "ide_dap::adapter",
-                                        "debug adapter failed to start on port {port}: {}; retrying",
-                                        e.message
-                                    );
-                                    continue;
-                                }
-                                return Err(e);
-                            }
-                        }
+                Some(port) => {
+                    if let Some(out) = child.stdout.take() {
+                        pump_lines(out, spec.adapter.clone(), stderr.clone(), program_sink.map(|tx| (tx, "stdout")));
                    }
-                    unreachable!("the retry loop returns on its last attempt")
+                    let timeout = if embedded.is_some() { EMBEDDED_START_TIMEOUT } else { CONNECT_TIMEOUT };
+                    let stream = match connect_with_retries(LOOPBACK, port, Some(&mut child), timeout).await {
+                        Ok(s) => s,
+                        Err(e) => {
+                            let _ = child.start_kill();
+                            let tail = stderr.lock().join("\n");
+                            return Err(if tail.is_empty() {
+                                e
+                            } else {
+                                IdeError::unavailable(format!("{}\n{tail}", e.message))
+                            });
+                        }
+                    };
+                    let (r, w) = stream.into_split();
+                    Ok(AdapterIo {
+                        reader: Box::new(r),
+                        writer: Box::new(w),
+                        child: Some(child),
+                        port: Some(port),
+                        stderr,
+                        program_output,
+                    })
                }
            }
        })
    }
 }

-/// Starts `binary` with `args`, then connects to it when `port` is set (a TCP adapter)
-/// or hands back its stdio when it is not. The child is stopped if it never accepts.
-async fn spawn_adapter(
-    spec: &AdapterSpec,
-    binary: &Path,
-    args: &[String],
-    port: Option<u16>,
-    start_timeout: Duration,
-) -> IdeResult<AdapterIo> {
-    let stderr = Arc::new(parking_lot::Mutex::new(Vec::new()));
-    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());
-    // Every adapter leads its own process group: the program an adapter launches itself
-    // (java-debug's JVM) joins the group, so a forced stop reaches the whole tree with
-    // one `kill(-pgid)`. On Windows the same coverage comes from the session's job object.
-    ide_core::process::own_group(cmd.as_std_mut());
-    cmd.args(args)
-        .envs(spec.env.iter().map(|(k, v)| (k, v)))
-        .current_dir(&spec.cwd)
-        .stdin(if port.is_some() { Stdio::null() } else { Stdio::piped() })
-        .stdout(Stdio::piped())
-        .stderr(Stdio::piped())
-        .kill_on_drop(true);
-    let mut child =
-        cmd.spawn().map_err(|e| IdeError::unavailable(format!("failed to start {}: {e}", binary.display())))?;
-    let (program_sink, program_output) = if SHARES_STDIO.contains(&spec.adapter.as_str()) {
-        let (tx, rx) = tokio::sync::mpsc::unbounded_channel();
-        (Some(tx), Some(rx))
-    } else {
-        (None, None)
-    };
-    if let Some(err) = child.stderr.take() {
-        pump_lines(err, spec.adapter.clone(), stderr.clone(), program_sink.clone().map(|tx| (tx, "stderr")));
-    }
-    match port {
-        None => {
-            let stdin = child.stdin.take().ok_or_else(|| IdeError::internal("adapter stdin unavailable"))?;
-            let stdout = child.stdout.take().ok_or_else(|| IdeError::internal("adapter stdout unavailable"))?;
-            Ok(AdapterIo {
-                launch_after_configuration: false,
-                reader: Box::new(stdout),
-                writer: Box::new(stdin),
-                child: Some(child),
-                port: None,
-                stderr,
-                program_output,
-            })
-        }
-        Some(port) => {
-            if let Some(out) = child.stdout.take() {
-                pump_lines(out, spec.adapter.clone(), stderr.clone(), program_sink.map(|tx| (tx, "stdout")));
-            }
-            let stream = match connect_with_retries(LOOPBACK, port, Some(&mut child), start_timeout).await {
-                Ok(s) => s,
-                Err(e) => {
-                    if spec.adapter == "rdbg"
-                        && let Some(pid) = child.id()
-                    {
-                        ide_core::process::kill_tree_of(pid);
-                    }
-                    let _ = child.start_kill();
-                    let tail = stderr.lock().join("\n");
-                    return Err(if tail.is_empty() {
-                        e
-                    } else {
-                        IdeError::unavailable(format!("{}\n{tail}", e.message))
-                    });
-                }
-            };
-            let (r, w) = stream.into_split();
-            Ok(AdapterIo {
-                launch_after_configuration: false,
-                reader: Box::new(r),
-                writer: Box::new(w),
-                child: Some(child),
-                port: Some(port),
-                stderr,
-                program_output,
-            })
-        }
-    }
-}
-
-/// A failed adapter start that another process grabbing the free port can explain
-/// (POSIX and Windows "address already in use" texts, or the adapter exiting because
-/// it could not bind). Anything else is a real start failure and is not retried.
-fn is_port_race(err: &IdeError) -> bool {
-    let message = err.message.to_ascii_lowercase();
-    message.contains("address already in use")
-        || message.contains("addrinuse")
-        || message.contains("only one usage of each socket address")
-        || message.contains("exited before accepting connections")
-}
-
 fn pump_lines<R: AsyncRead + Unpin + Send + 'static>(
    stream: R,
    name: String,
@@ -773,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();
@@ -844,102 +642,15 @@ mod tests {

    #[test]
    fn builtins_cover_common_adapters() {
-        for name in ["codelldb", "debugpy", "js-debug", "delve", "netcoredbg", "java-debug", "gdb"] {
+        for name in ["codelldb", "debugpy", "js-debug", "delve", "netcoredbg", "java-debug"] {
            let cfg = builtin(name).unwrap();
            assert!(cfg.install_hint.is_some());
        }
        let delve = resolve(&builtin("delve").unwrap(), PathBuf::from("/"));
        assert_eq!(delve.transport, Transport::Tcp);
-        // GDB's own DAP interpreter over stdio, with the required version in its hint.
-        let gdb = builtin("gdb").unwrap();
-        assert_eq!(gdb.command, "gdb");
-        assert_eq!(gdb.args, ["-i", "dap"]);
-        assert_eq!(gdb.transport, "stdio");
-        assert!(gdb.install_hint.as_deref().is_some_and(|h| h.contains("14")), "{gdb:?}");
-        assert_eq!(default_type("gdb"), Some("gdb"));
        assert!(builtin("nope").is_none());
    }

-    /// The first version number of `gdb --version`'s first line, however the distro decorates it.
-    #[test]
-    fn parses_gdb_versions() {
-        for (out, want) in [
-            ("GNU gdb (GDB) 14.2\nCopyright (C) 2023 Free Software Foundation", Some((14, 2))),
-            ("GNU gdb (GDB) 15.0.50.20240403-0ubuntu1\n", Some((15, 0))),
-            ("GNU gdb (Ubuntu 12.1-0ubuntu1~22.04.2) 12.1", Some((12, 1))),
-            ("GNU gdb (Debian 13.1-3) 13.1", Some((13, 1))),
-            ("GNU gdb (GDB) Fedora Linux 16.3-1.fc41", Some((16, 3))),
-            ("GNU gdb (GDB; SUSE Linux Enterprise 15) 14.2", Some((14, 2))),
-            ("GNU gdb (GDB; SUSE Linux Enterprise 15) 11.1", Some((11, 1))),
-            ("mingw32-gdb13.exe (GDB) 13.2", Some((13, 2))),
-            ("GNU gdb 14", Some((14, 0))),
-            ("no version here", None),
-            ("", None),
-        ] {
-            assert_eq!(parse_gdb_version(out), want, "{out}");
-        }
-    }
-
-    #[tokio::test]
-    async fn gdb_probe_never_executes_a_changed_pinned_program() {
-        let dir = tempfile::tempdir().unwrap();
-        let fake = dir.path().join(if cfg!(windows) { "gdb.cmd" } else { "gdb" });
-        std::fs::write(&fake, "approved").unwrap();
-        let pin = ProgramPin::approve(&fake).unwrap();
-        #[cfg(windows)]
-        std::fs::write(&fake, "@echo off\r\necho ran>probe-ran\r\necho GNU gdb (GDB) 15.1\r\n").unwrap();
-        #[cfg(unix)]
-        {
-            use std::os::unix::fs::PermissionsExt;
-            std::fs::write(&fake, "#!/bin/sh\ntouch probe-ran\necho 'GNU gdb (GDB) 15.1'\n").unwrap();
-            std::fs::set_permissions(&fake, std::fs::Permissions::from_mode(0o755)).unwrap();
-        }
-        let mut spec = resolve(&builtin("gdb").unwrap(), dir.path().to_owned());
-        spec.command = fake.to_string_lossy().into_owned();
-        spec.pinned = Some(pin);
-        let error = ProcessLauncher.launch(spec, None).await.err().expect("changed program is refused");
-        assert_eq!(error.kind, ide_core::error::ErrorKind::PermissionDenied);
-        assert!(!dir.path().join("probe-ran").exists(), "the version probe executed an unapproved program");
-    }
-
-    #[tokio::test]
-    async fn gdb_probe_uses_the_verified_program_and_launch_environment_once() {
-        use tokio::io::AsyncReadExt;
-        let dir = tempfile::tempdir().unwrap();
-        let fake = dir.path().join(if cfg!(windows) { "gdb.cmd" } else { "gdb" });
-        #[cfg(windows)]
-        std::fs::write(&fake, "@echo off\r\nif \"%~1\"==\"--version\" (\r\n echo probe>>probes\r\n echo GNU gdb ^(GDB^) %GDB_TEST_VERSION%\r\n) else (\r\n echo adapter\r\n)\r\n").unwrap();
-        #[cfg(unix)]
-        {
-            use std::os::unix::fs::PermissionsExt;
-            std::fs::write(&fake, "#!/bin/sh\nif [ \"$1\" = --version ]; then\n echo probe >> probes\n echo \"GNU gdb (GDB) $GDB_TEST_VERSION\"\nelse\n echo adapter\nfi\n").unwrap();
-            std::fs::set_permissions(&fake, std::fs::Permissions::from_mode(0o755)).unwrap();
-        }
-        let pin = ProgramPin::approve(&fake).unwrap();
-        for (version, deferred) in [("12.1", false), ("14.2", false), ("15.1", true), ("16.3", false)] {
-            let mut spec = resolve(&builtin("gdb").unwrap(), dir.path().to_owned());
-            // Only the approved path is executable; the symbolic command must never be probed.
-            spec.command = "definitely-not-a-real-binary-openidea".into();
-            spec.pinned = Some(pin.clone());
-            spec.env.push(("GDB_TEST_VERSION".into(), version.into()));
-            let result = ProcessLauncher.launch(spec, None).await;
-            if version == "12.1" {
-                let error = result.err().expect("GDB 12 has no DAP interpreter");
-                assert_eq!(error.kind, ide_core::error::ErrorKind::Unavailable);
-                assert!(error.message.contains("GDB 14 or newer"), "{}", error.message);
-                assert!(error.message.contains("12.1"), "{}", error.message);
-            } else {
-                let mut io = result.unwrap();
-                assert_eq!(io.launch_after_configuration, deferred, "{version}");
-                let mut output = String::new();
-                io.reader.read_to_string(&mut output).await.unwrap();
-                assert_eq!(output.trim(), "adapter");
-                io.child.as_mut().unwrap().wait().await.unwrap();
-            }
-        }
-        assert_eq!(std::fs::read_to_string(dir.path().join("probes")).unwrap().lines().count(), 4);
-    }
-
    #[test]
    fn free_port_is_nonzero() {
        assert_ne!(free_port().unwrap(), 0);
@@ -951,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]
@@ -1023,16 +734,4 @@ mod tests {
        assert_eq!(err.kind, ide_core::error::ErrorKind::Unavailable);
        assert!(err.message.contains("runs inside the Java language server"), "{}", err.message);
    }
-
-    #[test]
-    fn port_conflicts_are_recognised_for_retry() {
-        let in_use = IdeError::unavailable(
-            "debug adapter exited before accepting connections (exit status: 1)\nbind: address already in use",
-        );
-        assert!(is_port_race(&in_use));
-        assert!(is_port_race(&IdeError::unavailable(
-            "Only one usage of each socket address (protocol/network address/port) is normally permitted."
-        )));
-        assert!(!is_port_race(&IdeError::unavailable("failed to start codelldb: file not found")));
-    }
 }
@@ -246,7 +246,13 @@ impl Connection {

 fn dispatch(inner: &Inner, incoming: &mpsc::UnboundedSender<Incoming>, body: &[u8]) {
    tracing::trace!(target: "ide_dap::wire", "<-- {}", String::from_utf8_lossy(body));
-    let Some(msg) = parse_message(body) else { return };
+    let msg: Value = match serde_json::from_slice(body) {
+        Ok(v) => v,
+        Err(e) => {
+            tracing::warn!("dap: unparsable message: {e}");
+            return;
+        }
+    };
    match msg.get("type").and_then(Value::as_str) {
        Some("response") => {
            let Some(request_seq) = msg.get("request_seq").and_then(Value::as_i64) else {
@@ -279,25 +285,6 @@ fn dispatch(inner: &Inner, incoming: &mpsc::UnboundedSender<Incoming>, body: &[u
    }
 }

-/// A message body as JSON. Some adapters pass the debuggee's output through as it was
-/// written: netcoredbg on Windows embeds console output in the ANSI code page (GBK on a
-/// Chinese system), which isn't valid UTF-8 and made the whole `output` event unparsable,
-/// so every line with non-ASCII text went missing. Such a body is decoded like other tool
-/// output (UTF-8, else the system code page) before parsing.
-fn parse_message(body: &[u8]) -> Option<Value> {
-    let error = match serde_json::from_slice(body) {
-        Ok(v) => return Some(v),
-        Err(e) => e,
-    };
-    if std::str::from_utf8(body).is_err()
-        && let Ok(v) = serde_json::from_str(&ide_core::output_encoding::decode_tool_output(body))
-    {
-        return Some(v);
-    }
-    tracing::warn!("dap: unparsable message: {error}");
-    None
-}
-
 /// `message`, or the formatted `body.error` (`{format, variables}`) when present.
 fn error_message(msg: &Value) -> String {
    if let Some(err) = msg.pointer("/body/error")
@@ -319,22 +306,6 @@ fn error_message(msg: &Value) -> String {
 mod tests {
    use super::*;

-    #[test]
-    fn parses_output_events_with_non_utf8_text() {
-        // "中文" in GBK inside an output event, as netcoredbg sends it on a Chinese Windows.
-        let mut body = br#"{"seq":5,"type":"event","event":"output","body":{"category":"stdout","output":""#.to_vec();
-        body.extend_from_slice(&[0xd6, 0xd0, 0xce, 0xc4]);
-        body.extend_from_slice(br#"\n"}}"#);
-        let msg = parse_message(&body).expect("parsed");
-        assert_eq!(msg["event"], "output");
-        let output = msg["body"]["output"].as_str().unwrap();
-        assert!(output.ends_with('\n'));
-        // Off Windows (UTF-8 code page) the bytes decode lossily; the line still arrives.
-        #[cfg(not(windows))]
-        assert!(output.starts_with(char::REPLACEMENT_CHARACTER));
-        assert!(parse_message(b"{not json").is_none());
-    }
-
    #[test]
    fn formats_structured_errors() {
        let msg =
@@ -12,35 +12,6 @@ use tokio::net::{TcpListener, TcpStream};
 /// How long the relay waits for java-debug to attach once the JVM is connected.
 const ATTACH_TIMEOUT: Duration = Duration::from_secs(60);

-/// Loopback ports relaying a connected JVM, while their relay runs.
-static RELAY_PORTS: std::sync::Mutex<Vec<u16>> = std::sync::Mutex::new(Vec::new());
-
-fn relay_ports() -> std::sync::MutexGuard<'static, Vec<u16>> {
-    RELAY_PORTS.lock().unwrap_or_else(std::sync::PoisonError::into_inner)
-}
-
-/// Whether `port` is a relay of [`listen_for_jvm`]: a session attaching to it debugs a JVM that
-/// connected to the IDE, so the JVM has no JDWP listener the memory view could find it by.
-pub(crate) fn is_listen_relay(port: u16) -> bool {
-    relay_ports().contains(&port)
-}
-
-/// Registers a relay port for as long as it lives.
-struct RelayPort(u16);
-
-impl RelayPort {
-    fn new(port: u16) -> Self {
-        relay_ports().push(port);
-        Self(port)
-    }
-}
-
-impl Drop for RelayPort {
-    fn drop(&mut self) {
-        relay_ports().retain(|&p| p != self.0);
-    }
-}
-
 /// The address to listen on for `host`: the interface it names, or every interface when
 /// it is not one of this machine's (a DNS name or a NAT address the JVM connects to).
 async fn bind(host: &str, port: u16) -> IdeResult<TcpListener> {
@@ -69,11 +40,11 @@ pub async fn listen_for_jvm(host: &str, port: u16, cancel: CancellationToken) ->
    let _ = jvm.set_nodelay(true);
    let relay = TcpListener::bind(("127.0.0.1", 0)).await?;
    let local = relay.local_addr()?.port();
-    tokio::spawn(relay_one(relay, jvm, RelayPort::new(local)));
+    tokio::spawn(relay_one(relay, jvm));
    Ok(local)
 }

-async fn relay_one(relay: TcpListener, mut jvm: TcpStream, _registered: RelayPort) {
+async fn relay_one(relay: TcpListener, mut jvm: TcpStream) {
    let debugger = match tokio::time::timeout(ATTACH_TIMEOUT, relay.accept()).await {
        Ok(Ok((s, _))) => s,
        _ => return,
@@ -87,64 +58,22 @@ async fn relay_one(relay: TcpListener, mut jvm: TcpStream, _registered: RelayPor
 }

 #[cfg(test)]
-pub(crate) mod tests {
+mod tests {
    use super::*;
    use tokio::io::{AsyncReadExt, AsyncWriteExt};

-    /// A remote JVM (`server=n`) connected to [`listen_for_jvm`], and the relay port. A port
-    /// picked by binding to 0 can be taken by a parallel test before `listen_for_jvm` binds it,
-    /// so a failed listen is retried on a fresh one.
-    pub(crate) async fn connected_jvm() -> (TcpStream, u16) {
-        for _ in 0..20 {
-            let port = TcpListener::bind(("127.0.0.1", 0)).await.unwrap().local_addr().unwrap().port();
-            if let Some(connected) = jvm_on(port).await {
-                return connected;
-            }
-        }
-        panic!("listen_for_jvm never accepted a JVM");
-    }
-
-    /// One attempt of [`connected_jvm`]; `None` when the port turned out to be taken.
-    async fn jvm_on(port: u16) -> Option<(TcpStream, u16)> {
-        let mut waiting = tokio::spawn(listen_for_jvm("127.0.0.1", port, CancellationToken::new()));
-        let mut jvm = None;
-        for _ in 0..100 {
-            // A listen that failed to bind leaves nothing to connect to.
-            if waiting.is_finished() {
-                break;
-            }
-            // macOS does not refuse a connect to a port a socket holds without listening: the
-            // SYN goes unanswered until the connect times out.
-            let connect = TcpStream::connect(("127.0.0.1", port));
-            if let Ok(Ok(s)) = tokio::time::timeout(Duration::from_secs(1), connect).await {
-                jvm = Some(s);
-                break;
-            }
-            tokio::time::sleep(Duration::from_millis(20)).await;
-        }
-        // A connection to another test's listener never reaches `listen_for_jvm`.
-        let relay = tokio::time::timeout(Duration::from_secs(2), &mut waiting).await;
-        if let (Some(jvm), Ok(Ok(Ok(relay)))) = (jvm, relay) {
-            return Some((jvm, relay));
-        }
-        waiting.abort();
-        None
-    }
-
-    #[tokio::test]
-    async fn a_port_another_socket_holds_is_given_up() {
-        // Bound but not listening, as a parallel test's outgoing connection holds its local port.
-        let held = tokio::net::TcpSocket::new_v4().unwrap();
-        held.bind(([127, 0, 0, 1], 0).into()).unwrap();
-        let port = held.local_addr().unwrap().port();
-        let attempt = tokio::time::timeout(Duration::from_secs(5), jvm_on(port)).await;
-        assert!(matches!(attempt, Ok(None)), "an attempt on a taken port gives up instead of waiting forever");
-    }
-
    #[tokio::test]
    async fn relays_the_jdwp_handshake_both_ways() {
+        let port = TcpListener::bind(("127.0.0.1", 0)).await.unwrap().local_addr().unwrap().port();
+        let waiting = tokio::spawn(listen_for_jvm("127.0.0.1", port, CancellationToken::new()));
        // The remote JVM (`server=n`) connects to the IDE.
-        let (mut jvm, local) = connected_jvm().await;
+        let mut jvm = loop {
+            if let Ok(s) = TcpStream::connect(("127.0.0.1", port)).await {
+                break s;
+            }
+            tokio::time::sleep(Duration::from_millis(20)).await;
+        };
+        let local = waiting.await.unwrap().unwrap();
        // java-debug attaches to the relay and starts the handshake.
        let mut debugger = TcpStream::connect(("127.0.0.1", local)).await.unwrap();
        debugger.write_all(b"JDWP-Handshake").await.unwrap();
@@ -156,22 +85,6 @@ pub(crate) mod tests {
        assert_eq!(&buf, b"JDWP-Handshake");
    }

-    #[tokio::test]
-    async fn relay_port_is_known_while_the_relay_runs() {
-        let (jvm, local) = connected_jvm().await;
-        assert!(is_listen_relay(local));
-
-        let debugger = TcpStream::connect(("127.0.0.1", local)).await.unwrap();
-        drop((jvm, debugger));
-        for _ in 0..200 {
-            if !is_listen_relay(local) {
-                return;
-            }
-            tokio::time::sleep(Duration::from_millis(10)).await;
-        }
-        panic!("relay port {local} still registered after the relay ended");
-    }
-
    #[tokio::test]
    async fn waiting_is_cancellable() {
        let cancel = CancellationToken::new();
@@ -1,92 +0,0 @@
-//! The class table counted by the debugger (JDWP `InstanceCounts`) where no histogram can be
-//! taken: JDK 8-16 while suspended, Windows, a remote JVM. Only while suspended, and slow on a
-//! large heap (seconds on JDK 17+).
-
-use super::inspect::Call;
-use super::snapshot::diff_rows;
-use super::{ClassCounts, JvmMemoryResult, JvmMemorySnapshot, JvmMemorySource, JvmMemoryState, JvmMemoryUnavailable};
-use crate::session::Session;
-use ide_core::IdeResult;
-use ide_jvm_attach::HistogramRow;
-use ide_jvm_inspect::ClassCount;
-
-/// Reasons the debugger may be able to work around; the others (the program exited, the JVM
-/// did not answer) would fail for it too.
-pub(super) fn falls_back(reason: &JvmMemoryUnavailable) -> bool {
-    use JvmMemoryUnavailable as U;
-    matches!(
-        reason,
-        U::UnsafeWhileSuspended { .. }
-            | U::UnsupportedPlatform
-            | U::AttachedJvmNotFound
-            | U::ListenerNotRunning
-            | U::ListenModeNotSupported
-            | U::NoJvmProcess
-    )
-}
-
-/// `histogram` unless it is unavailable for a reason `session`'s inspector can work around.
-pub(super) async fn or_debugger_counts(
-    state: &mut JvmMemoryState,
-    histogram: Result<JvmMemorySnapshot, JvmMemoryUnavailable>,
-    session: Option<&Session>,
-) -> IdeResult<JvmMemoryResult> {
-    let reason = match histogram {
-        Ok(snapshot) => return Ok(JvmMemoryResult::Ready { snapshot }),
-        Err(reason) => reason,
-    };
-    let unavailable = |can_count_when_paused| Ok(JvmMemoryResult::Unavailable { reason, can_count_when_paused });
-    let Some(session) = session.filter(|_| falls_back(&reason)) else {
-        return unavailable(false);
-    };
-    let call = match Call::begin(session, None).await {
-        Ok(call) => call,
-        Err(super::JvmInspectUnavailable::NotSuspended) => return unavailable(true),
-        Err(_) => return unavailable(false),
-    };
-    let started = std::time::Instant::now();
-    let result = call.run(call.inspector.class_counts(&call.target)).await;
-    match call.finish(result) {
-        Ok(counts) => {
-            let elapsed_ms = u32::try_from(started.elapsed().as_millis()).unwrap_or(u32::MAX);
-            let previous = state.baseline(JvmMemorySource::Debugger);
-            let (snapshot, counts) = debugger_snapshot(counts, previous.as_deref(), elapsed_ms);
-            state.remember(JvmMemorySource::Debugger, counts);
-            Ok(JvmMemoryResult::Ready { snapshot })
-        }
-        Err(e) => {
-            tracing::debug!("debugger class counts: {e}");
-            let running = !session.suspended.get();
-            unavailable(running && session.jvm_inspector.lock().is_some())
-        }
-    }
-}
-
-/// Classes without instances are left out; most instances first.
-pub(super) fn debugger_snapshot(
-    counts: Vec<ClassCount>,
-    previous: Option<&ClassCounts>,
-    elapsed_ms: u32,
-) -> (JvmMemorySnapshot, ClassCounts) {
-    let rows = counts
-        .into_iter()
-        .filter(|c| c.instances > 0)
-        .map(|c| HistogramRow { name: c.name, module: None, instances: c.instances, bytes: 0 })
-        .collect();
-    let (mut rows, counts) = diff_rows(rows, previous);
-    for row in &mut rows {
-        row.delta_bytes = None;
-    }
-    rows.sort_by(|a, b| b.instances.cmp(&a.instances).then_with(|| a.name.cmp(&b.name)));
-    let snapshot = JvmMemorySnapshot {
-        total_instances: rows.iter().map(|r| r.instances).sum(),
-        total_bytes: 0,
-        rows,
-        java_version: String::new(),
-        taken_while_suspended: true,
-        has_baseline: previous.is_some(),
-        elapsed_ms,
-        source: JvmMemorySource::Debugger,
-    };
-    (snapshot, counts)
-}