feat(jetbrains): download pinned Kilo Core releases at runtime

.changeset/jetbrains-download-cli.md

@@ -0,0 +1,5 @@
+---
+"@kilocode/kilo-jetbrains": patch
+---
+
+Reduce JetBrains plugin size by downloading the Kilo Core release on first connect.

.changeset/jetbrains-prune-old-cli.md

@@ -0,0 +1,5 @@
+---
+"@kilocode/kilo-jetbrains": patch
+---
+
+Remove old JetBrains CLI binaries so they no longer accumulate in the IDE cache. Only the active version is kept, the downloaded archive is deleted after extraction, and reinstalling re-downloads a fresh binary.

.github/workflows/publish-jetbrains.yml

@@ -125,19 +125,11 @@ jobs:
           JETBRAINS_PRIVATE_KEY: ${{ secrets.JETBRAINS_PRIVATE_KEY }}
           JETBRAINS_PRIVATE_KEY_PASSWORD: ${{ secrets.JETBRAINS_PRIVATE_KEY_PASSWORD }}
 
-      - name: Prepare CLI resources
-        working-directory: packages/kilo-jetbrains
-        run: bun script/build.ts --production --prepare-cli
-        env:
-          KILO_VERSION: ${{ steps.release.outputs.version }}
-          KILO_CHANNEL: ${{ steps.release.outputs.cli_channel }}
-          GH_TOKEN: ${{ github.token }}
-          GH_REPO: ${{ github.repository }}
-
       - name: Verify plugin
         working-directory: packages/kilo-jetbrains
         run: ./gradlew verifyPlugin -Pproduction=true -Pkilo.channel="$CHANNEL"
         env:
+          GH_TOKEN: ${{ github.token }}
           VERSION: ${{ steps.release.outputs.version }}
           CHANNEL: ${{ steps.release.outputs.marketplace_channel }}
 

.kilo/skills/release-jetbrains/SKILL.md

@@ -34,7 +34,40 @@ Accepted specs:
 | `x.y.z-rc.n` | Explicit RC release. |
 | `x.y.z` | Explicit stable release. |
 
-Show the resolved `version`, `kind`, and default `fromTagDefault` to the user and ask for confirmation before continuing.
+Show the resolved `version`, `kind`, and default `fromTagDefault` to the user.
+
+## CLI Pin Verification
+
+Before dispatching prepare, verify the JetBrains plugin is pinned to the intended Kilo Core release. The plugin downloads the CLI version from `packages/kilo-jetbrains/package.json`, not from the JetBrains plugin version.
+
+Read the pinned CLI version:
+
+```bash
+bun -e 'const p=require("./packages/kilo-jetbrains/package.json"); console.log(p.version)'
+```
+
+Verify the matching GitHub Release exists and includes every runtime asset the backend may download:
+
+```bash
+cli_version="7.4.1"
+gh release view "v${cli_version}" --repo Kilo-Org/kilocode --json assets \
+  --jq '.assets[].name' | sort
+```
+
+Expected assets:
+
+```text
+kilo-darwin-arm64.zip
+kilo-darwin-x64.zip
+kilo-linux-arm64.tar.gz
+kilo-linux-x64.tar.gz
+kilo-windows-arm64.zip
+kilo-windows-x64.zip
+```
+
+If the pin is stale or the release assets are missing, stop and ask the user to update `packages/kilo-jetbrains/package.json` on `main` before dispatching prepare. The prepare workflow tags `origin/main`, so the pin must already be reviewed and merged before the release tag is created.
+
+Show the resolved JetBrains plugin version, release kind, default `fromTagDefault`, pinned CLI version, and CLI release asset status to the user, then ask for confirmation before continuing.
 
 ## Prepare Workflow
 

CONTRIBUTING.md

@@ -126,10 +126,10 @@ Requires Java 21 (see [Prerequisites](#prerequisites)). From `packages/kilo-jetb
 ```bash
 ./gradlew typecheck    # Compile-check all Kotlin sources
 ./gradlew test         # Run all tests (backend + frontend)
-./gradlew --no-configuration-cache runIdeSplitMode  # Launch local split-mode sandbox and prepare the CLI
+./gradlew --no-configuration-cache runIdeSplitMode  # Launch local split-mode sandbox; backend downloads the pinned CLI
 ```
 
-Use `./gradlew runIde` only for a monolithic sandbox; prepare the CLI first with `bun run build --prepare-cli`.
+Use `./gradlew runIde` only for a monolithic sandbox. JetBrains dev runs do not build or bundle CLI binaries; the backend downloads the pinned release at connect time.
 
 Or via the root turbo filter to run only JetBrains checks from the repo root:
 

packages/kilo-docs/pages/contributing/architecture/jetbrains-plugin.md

@@ -131,10 +131,10 @@ JetBrains Kotlin toolchain is Java 21. Gradle commands report missing or incompa
 | Typecheck | `./gradlew typecheck` |
 | Tests | `./gradlew test` |
 | Full plugin build | `bun run build` |
-| Gradle plugin assembly with prepared CLI binaries | `./gradlew buildPlugin` |
+| Gradle plugin assembly with pinned CLI download | `./gradlew buildPlugin` |
 | Split-mode sandbox | `./gradlew --no-configuration-cache runIdeSplitMode` |
 | Split backend sandbox | `./gradlew --no-configuration-cache runIdeBackend` |
-| Monolithic sandbox IDE | `./gradlew runIde` after `bun run build --prepare-cli` |
+| Monolithic sandbox IDE | `./gradlew runIde` |
 
 Run `Plugin DevKit | Code | Frontend and Backend API Usage` inspection when moving code across split boundary.
 

packages/kilo-jetbrains/.gitignore

@@ -16,3 +16,8 @@ bin/
 **/.kotlin/
 **/bin/
 !gradle/wrapper/gradle-wrapper.jar
+
+# Downloaded CLI artifacts
+**/cli-cache/
+kilo-*.zip
+kilo-*.tar.gz

packages/kilo-jetbrains/AGENTS.md

@@ -14,7 +14,7 @@
 
 - `plugin.xml` `<content>` entries ↔ module XML descriptors (`kilo.jetbrains.{shared,frontend,backend}.xml`)
 - Service classes ↔ `<applicationService>`/`<projectService>` entries in the corresponding module XML
-- `script/build.ts` platform list ↔ `backend/build.gradle.kts` `requiredPlatforms` list
+- `packages/kilo-jetbrains/package.json` version ↔ GitHub CLI release tag consumed by the backend downloader
 
 ## IntelliJ Platform Source Lookup
 
@@ -153,7 +153,9 @@ For blocking I/O in coroutines, move the dispatcher switch inside the callee usi
 
 ## CLI Integration
 
-- CLI process spawning, extraction, and lifecycle belong in `backend`.
+- CLI process spawning, download, extraction, and lifecycle belong in `backend`.
+- The plugin does not bundle CLI binaries. At connect time the backend downloads the GitHub Release asset for the version pinned in `packages/kilo-jetbrains/package.json`; `backend` resources include `kilo.properties` with `cli.version` for split-mode RPC and runtime use.
+- The generated API client is produced from the pinned release binary by running `kilo generate` during the Gradle OpenAPI generation task.
 - For OS and environment checks, prefer IntelliJ Platform classes over raw JVM APIs such as `System.getProperty(...)` or `System.getenv(...)`.
 - Detect architecture with `com.intellij.util.system.CpuArch.CURRENT`, not `System.getProperty("os.arch")`.
 - Detect OS with `com.intellij.openapi.util.SystemInfo.isMac` / `isLinux` / `isWindows`.
@@ -187,22 +189,21 @@ For blocking I/O in coroutines, move the dispatcher switch inside the callee usi
 
 ## Build and Verification
 
-- **Marketplace version build**: Use `script/build-version.sh <version>` from `packages/kilo-jetbrains/` to clean, prepare production CLI binaries, build, sign, and verify the JetBrains Marketplace plugin ZIP. Pass `--skip-verification` only when explicitly needed.
+- **Marketplace version build**: Use `script/build-version.sh <version>` from `packages/kilo-jetbrains/` to clean, build, sign, and verify the JetBrains Marketplace plugin ZIP. Pass `--skip-verification` only when explicitly needed.
 - **Test version build**: If the user asks for a JetBrains test build, still require a version and use `script/build-version.sh <version> --skip-signing --skip-verification` from `packages/kilo-jetbrains/` so no signing secrets are needed. Add `--skip-clean` only when the user wants a faster incremental test build.
-- **Typecheck**: `bun run typecheck` or `./gradlew typecheck` from `packages/kilo-jetbrains/` — compiles all Kotlin sources including the generated API client. Does NOT require CLI binaries.
-- **Full build**: `bun run build` from `packages/kilo-jetbrains/` (prepares CLI binaries + runs Gradle `buildPlugin`).
-- **Gradle only**: `./gradlew buildPlugin` from `packages/kilo-jetbrains/` (requires CLI binaries already present in `backend/build/generated/cli/`; run `bun run build --prepare-cli` first).
+- **Typecheck**: `bun run typecheck` or `./gradlew typecheck` from `packages/kilo-jetbrains/` — compiles all Kotlin sources including the generated API client. A cold build downloads the pinned CLI release via `generateOpenApiSpec` and needs network access; Gradle-cached incremental runs skip the download. It does not bundle per-platform CLI binaries.
+- **Full build**: `bun run build` from `packages/kilo-jetbrains/` (runs Gradle `buildPlugin`).
+- **Gradle only**: `./gradlew buildPlugin` from `packages/kilo-jetbrains/`.
 - **Java checks**: Do not run `java -version` as a routine preflight. Gradle commands already fail clearly when Java is missing or incompatible; check Java only when diagnosing that failure mode.
 - **Via Turbo**: `bun turbo build --filter=@kilocode/kilo-jetbrains` from repo root.
-- **Run split mode**: `./gradlew --no-configuration-cache runIdeSplitMode` or the checked-in `Run IDE (Split Mode)` configuration — launches backend and frontend locally and prepares the local-platform CLI binary automatically. Emulate latency via the Split Mode widget (requires internal mode: `-Didea.is.internal=true`).
-- **Run split backend**: `./gradlew --no-configuration-cache runIdeBackend` — prepares the local-platform CLI binary automatically; if it exits shortly after startup, check for an orphaned Java process from a previous backend run and kill it before restarting.
-- **Run in monolithic sandbox**: `./gradlew runIde` — launches sandboxed IntelliJ with the plugin. Does NOT build CLI binaries.
+- **Run split mode**: `./gradlew --no-configuration-cache runIdeSplitMode` or the checked-in `Run IDE (Split Mode)` configuration — launches backend and frontend locally. Emulate latency via the Split Mode widget (requires internal mode: `-Didea.is.internal=true`).
+- **Run split backend**: `./gradlew --no-configuration-cache runIdeBackend` — if it exits shortly after startup, check for an orphaned Java process from a previous backend run and kill it before restarting.
+- **Run in monolithic sandbox**: `./gradlew runIde` — launches sandboxed IntelliJ with the plugin. Does not build or bundle CLI binaries; the backend downloads the pinned release at connect time.
 
 ### CLI/SDK Change Awareness
 
-- JetBrains runtime behavior depends on the bundled CLI artifact under `backend/build/generated/cli/`; Gradle-only tasks and sandbox runs do not rebuild it.
-- If there are relevant changes outside `packages/kilo-jetbrains/` in the CLI (`packages/opencode/`) or SDK/API generation paths (`packages/sdk/js/`, server endpoints, OpenAPI outputs), warn the user that the JetBrains run may be using stale generated CLI or SDK artifacts.
-- Do not regenerate or rebuild those artifacts automatically just because such changes exist. Ask the user whether to refresh them first, typically with `bun run build --prepare-cli` from `packages/kilo-jetbrains/` for CLI artifacts and `./script/generate.ts` from the repo root for server/API SDK changes.
+- JetBrains runtime behavior depends on the downloaded CLI release pinned by `packages/kilo-jetbrains/package.json`; local `packages/opencode/` changes are not used unless published and pinned.
+- If there are relevant server/API changes outside `packages/kilo-jetbrains/`, warn the user that JetBrains may need a newly published/pinned CLI release and regenerated SDK artifacts.
 
 ## UI Guidelines
 

packages/kilo-jetbrains/README.md

@@ -10,7 +10,7 @@ To try the v7 Early Access Program plugin, follow the [JetBrains EAP installatio
 
 ### Prerequisites
 
-- **Bun** -- used to build CLI binaries and run build scripts
+- **Bun** -- used to run package build scripts
 - **JDK 21+** -- required by Gradle and the IntelliJ Platform SDK. Check with `java -version`. The preferred way to install is via [SDKMAN](https://sdkman.io/install):
 
   ```bash
@@ -34,7 +34,7 @@ When working in a git worktree (e.g. via the Agent Manager), run `bun install` f
 bun install
 ```
 
-This installs Node dependencies required by the build scripts, including `script/build.ts` which prepares CLI binaries.
+This installs Node dependencies required by the build scripts.
 
 ---
 
@@ -52,7 +52,7 @@ From `packages/kilo-jetbrains/`:
 bun run build
 ```
 
-This builds the CLI binary for your current OS/arch only, copies it into the backend module resources, and runs `./gradlew buildPlugin`. The plugin archive is output to `build/distributions/`.
+This builds the plugin without bundling CLI binaries. The backend downloads the pinned Kilo CLI release for the host platform at connect time. The plugin archive is output to `build/distributions/`.
 
 Or via Turbo from the repo root:
 
@@ -70,7 +70,7 @@ From `packages/kilo-jetbrains/`:
 bun run build:production
 ```
 
-This builds CLI binaries for all 6 desktop platforms (darwin-arm64, darwin-x64, linux-arm64, linux-x64, windows-x64, windows-arm64), copies them all into the backend jar, and fails if any are missing. Gradle also validates all platforms are present via `-Pproduction=true`.
+This builds the plugin without bundling CLI binaries. The backend downloads the pinned Kilo CLI release for the host platform at connect time.
 
 The built plugin archive is at `build/distributions/kilo.jetbrains-<version>.zip`. This zip can be installed in any JetBrains IDE via **Settings > Plugins > Install Plugin from Disk**.
 
@@ -84,15 +84,15 @@ See [RELEASING.md](RELEASING.md) for the full release process, including how to
 
 ## Run the plugin
 
-Use the checked-in `Run IDE (Split Mode)` run configuration (or `./gradlew --no-configuration-cache runIdeSplitMode` from `packages/kilo-jetbrains/`) to launch the backend and frontend halves of a local split-mode sandbox. The task prepares the local-platform CLI binary automatically when `backend/build/generated/cli/cli/` does not contain the expected binary.
+Use the checked-in `Run IDE (Split Mode)` run configuration (or `./gradlew --no-configuration-cache runIdeSplitMode` from `packages/kilo-jetbrains/`) to launch the backend and frontend halves of a local split-mode sandbox. The backend downloads the pinned CLI release on first connect.
 
-Use `runIde` only when you need a monolithic sandboxed IntelliJ instance. `runIde` does not prepare the CLI binary automatically, so run `bun run build --prepare-cli` from `packages/kilo-jetbrains/` first to copy the local-platform binary into `backend/build/generated/cli/cli/`.
+Use `runIde` only when you need a monolithic sandboxed IntelliJ instance.
 
-Production packaging still requires running `bun run build:production` so all platform binaries are present.
+Production packaging uses `bun run build:production` and still downloads the host CLI at runtime.
 
 ### Run the split backend
 
-Use the checked-in `Run IDE (Backend)` run configuration (or `./gradlew --no-configuration-cache runIdeBackend`) to launch just the backend half of a split-mode session. It prepares the local-platform CLI binary automatically when `backend/build/generated/cli/cli/` does not contain the expected binary.
+Use the checked-in `Run IDE (Backend)` run configuration (or `./gradlew --no-configuration-cache runIdeBackend`) to launch just the backend half of a split-mode session.
 
 If `Run IDE (Backend)` exits shortly after startup, check for an orphaned Java process from a previous backend run and kill it before restarting the backend.
 
@@ -107,7 +107,6 @@ All properties below are passed with `-P` on the Gradle command line or in the r
 | `kilo.splitModeServerPort` | `0` | Backend split-mode server port. `0` or omitted lets the IntelliJ Platform Gradle Plugin pick a free port when the task runs. |
 | `kilo.dev.storage.isolated` | `false` | When `true`, CLI runs with `XDG_*_HOME` pointing to `.kilo-dev/` in the worktree root, fully isolating dev storage from your real Kilo installation. Enabled by default in the checked-in split-mode run configurations. |
 | `kilo.dev.worktree.root` | monorepo root | Worktree root used to resolve `.kilo-dev/`. Auto-detected from the Gradle project directory; override only when the auto-detection is wrong. |
-| `kilo.bun.path` | `bun` on `$PATH` | Absolute path to Bun. Set this when IntelliJ-launched Gradle cannot find Bun automatically. |
 
 The checked-in IDE run configurations pass `--no-configuration-cache` because the IntelliJ Platform Gradle Plugin run-IDE tasks are not configuration-cache compatible in this setup.
 They also pass `--purge-old-log-directories` so stale sandbox logs do not hide the current backend and frontend `kilo-dev.log` files.
@@ -195,9 +194,7 @@ For direct local packaging, run:
 bun run build
 ```
 
-This prepares the local CLI binary and then runs `./gradlew buildPlugin`.
-
-If you run `./gradlew buildPlugin` directly, Gradle verifies CLI binaries are present but does not build them first. Run `bun run build --prepare-cli` beforehand if the binaries are missing.
+This runs `./gradlew buildPlugin`.
 
 For production verification:
 

packages/kilo-jetbrains/RELEASING.md

@@ -8,6 +8,8 @@ The published code comes from `jetbrains/v<version>`. Marketplace and GitHub rel
 
 Maintainers can use the Kilo `release-jetbrains` skill to drive this process from a version request such as `next rc` or an explicit version. The skill resolves and confirms the version, dispatches and watches the prepare workflow, helps produce a filtered human-readable JetBrains/CLI changelog draft, commits the reviewed changelog to the release PR, and watches publishing after the PR is merged.
 
+JetBrains plugin builds and runtime downloads use the Kilo Core version pinned in `packages/kilo-jetbrains/package.json`, so verify that pin points at a published `v<version>` release before creating the release tag.
+
 The skill lives at `.kilo/skills/release-jetbrains/SKILL.md`. It does not move or recreate release tags, and merge permission is only required if the user explicitly asks the skill to merge the release PR automatically.
 
 ## Create Release Tag And PR