ur-agent 1.44.10 → 1.45.3

package/docs/AGENT_FEATURES.md

@@ -71,12 +71,16 @@ ur auth gemini
 ur auth antigravity
 ur config set provider ollama
 ur config set provider openai-compatible
-ur config set model qwen3-coder:480b-cloud
+ur config set model qwen2.5-coder:7b
 ur config set base_url http://localhost:11434/v1
 ur config set provider.fallback ollama
 ur upgrade
 ```
 
+The optional `provider.fallback` value is used only to print an explicit
+recovery recommendation in provider diagnostics. It never silently or
+automatically changes the active provider.
+
 ## v1.25.x Additions
 
 | Addition | Surface | What it adds |
@@ -135,8 +139,8 @@ components instead of one giant prompt.
 
 | Addition | Surface | What it adds |
 | --- | --- | --- |
-| Agent skill runner | `src/services/agents/agentSkillRunner.ts` | Reusable wrapper around `startBackgroundTask({ worktree: true, pr: true })` that polls to completion and returns a PR-style summary. |
-| Worktree slash skills | `/debug-v2`, `/refactor`, `/paper-implementation`, `/benchmark`, `/security-review`, `/dockerize`, `/latex-paper` | Bundled slash skills that expand into prompts for isolated worktree work with clean commits and PR output. |
+| Agent skill runner | `src/services/agents/agentSkillRunner.ts` | Reusable isolated-worktree wrapper that polls to completion; PR creation is available only with explicit `createPr: true`. |
+| Worktree slash skills | `/debug-v2`, `/refactor`, `/paper-implementation`, `/benchmark`, `/security-review`, `/dockerize`, `/latex-paper`, `/batch` | Bundled slash skills keep changes local, run focused checks, ask before the final full suite, and never publish automatically. |
 | Agent templates | `ur agent-templates install` | Adds `debug-v2`, `refactor`, `paper-implementation`, `benchmark`, `security-review`, `dockerize`, and `latex-paper` reusable agent templates under `.ur/agents/`. |
 | Worktree command | `ur worktree list\|status\|clean` | Inspect and clean up UR agent worktrees created by `ur bg` or slash skills. |
 
@@ -269,7 +273,7 @@ runners, so the core logic is deterministic and unit-tested offline.
 | Spec-driven development | `ur spec init\|generate\|approve\|run\|status` + `.ur/specs/` | requirements -> design -> tasks documents and a phase/approval record; executes the Spec Kit / Kiro `- [ ] T1: ...` task list one task at a time, checking off each PASS |
 | In-loop model escalation | `ur escalate plan\|run\|oracle\|policy` + `.ur/escalation.json` | capability-aware fast/oracle tiers from `model-doctor`; routine work runs fast and auto-escalates hard/failed work to the strong model; `oracle` is a one-shot second opinion |
 | Best-of-N judging | `ur arena "<task>" [--agents N] [--apply]` | runs N agents on one task in isolated worktrees, scores diffs with the self-review gate + verdict/diff heuristics, surfaces (optionally applies) the winner |
-| Self-healing CI loop | `ur ci-loop [--command ...] [--commit] [--push]` | run -> on failure summarize -> fix agent -> re-run, bounded by retries; commits/pushes are self-review gated; `--from-log` seeds the first failure |
+| Self-healing CI loop | `ur ci-loop [--command ...] [--cwd ...] [--commit] [--push]` | run -> on failure summarize -> fix agent -> re-run, bounded by retries; no-test failures stop immediately with cwd guidance; commits/pushes are self-review gated; `--from-log` seeds the first failure |
 | Verifiable artifacts | `ur artifacts add\|capture-diff\|capture-tests\|approve\|reject` + `.ur/artifacts/` | reviewable deliverables with pending/approved/rejected status and threaded feedback; threads into the provenance stack (`claim-ledger`, `trace`, `evidence`) |
 
 ### Commands

package/docs/CONFIGURATION.md

@@ -58,6 +58,10 @@ ur provider select-model <provider> <model> --json
 ur config set base_url <url>
 ```
 
+`provider.fallback` is diagnostic recovery metadata, not automatic routing.
+When the active provider fails, `ur provider doctor` shows the configured
+recovery command; changing providers remains an explicit user action.
+
 Provider values accept canonical IDs and common aliases. Examples:
 `openai-api`, `anthropic-api`, `gemini-api`, `openrouter`, `ollama`,
 `lmstudio`, `LM Studio`, `llama.cpp`, `vllm`, and the subscription CLI
@@ -88,6 +92,7 @@ it in the environment when you explicitly choose API mode:
 
 ```sh
 OPENAI_API_KEY=...
+OPENAI_COMPATIBLE_API_KEY=...
 ANTHROPIC_API_KEY=...
 GEMINI_API_KEY=...
 OPENROUTER_API_KEY=...
@@ -117,8 +122,8 @@ ur --settings '{"ollama":{"host":"http://192.168.1.50:11434"}}'
 Model selection environment variables still work the same way:
 
 ```sh
-OLLAMA_MODEL=qwen3-coder:480b-cloud
-UR_MODEL=qwen3-coder:480b-cloud
+OLLAMA_MODEL=qwen2.5-coder:7b
+UR_MODEL=qwen2.5-coder:7b
 ```
 
 `OLLAMA_MODEL` selects the model name and takes precedence over `UR_MODEL` only

package/docs/IDE.md

@@ -4,8 +4,7 @@ UR's professional IDE integration is the **UR Inline Diffs** VS Code extension,
 bundled in this repository (`extensions/vscode-ur-inline-diffs`). It gives VS
 Code, Cursor, and Windsurf a chat panel, inline diff review, an actions panel,
 an agent status card, a searchable command palette, and an agent options
-panel — all driven by the same `ur` CLI you already use from a terminal, with
-no separate server process and no new network surface.
+panel — all driven by the same `ur` CLI you already use from a terminal.
 
 Other editors connect through different mechanisms, chosen per editor and
 stated honestly — nothing here claims support that does not exist:
@@ -19,12 +18,12 @@ stated honestly — nothing here claims support that does not exist:
   Neovim clients. This remains a separate transport from the VS Code
   extension's chat bridge below; the two are independent and neither depends
   on the other.
-- **Manual** — no auto-config; install a plugin and connect via `/ide`.
-  **JetBrains is not implemented in this repository.** UR can detect whether
-  a plugin named `ur-jetbrains-plugin` is installed
-  (`src/utils/jetbrains.ts`), but this repo does not build, ship, or publish
-  that plugin. Nothing in this document should be read as "install our
-  JetBrains plugin today" — there isn't one yet.
+- **JetBrains plugin** — the experimental bundled plugin under
+  `extensions/jetbrains-ur` connects to `ur acp serve` on loopback. It uses
+  JSON-RPC `initialize`, `session/new`, and `session/prompt` calls at `/acp`,
+  preserves a project-scoped session, and performs network work off the IDE UI
+  thread. It is installable from its `buildPlugin` zip; marketplace publishing
+  is not claimed.
 
 ## Supported targets
 
@@ -34,7 +33,7 @@ stated honestly — nothing here claims support that does not exist:
 | Cursor | UR Inline Diffs extension (VS Code fork) | `.vscode/settings.json` | Same extension as VS Code. |
 | Windsurf | UR Inline Diffs extension (VS Code fork) | `.vscode/settings.json` | Same extension as VS Code. |
 | Zed | stdio ACP | `.zed/settings.json` | Real Agent Client Protocol over stdio. |
-| JetBrains | not implemented | none | Detection code exists; no plugin ships from this repo. Use the CLI directly in the meantime. |
+| JetBrains | bundled experimental plugin + HTTP ACP | manual zip install | Project-scoped JSON-RPC session and Send Selection action; synchronous ACP task result, not token streaming. |
 | Neovim | stdio ACP | snippet | Requires a third-party ACP client plugin. |
 | Generic ACP | stdio ACP / HTTP | snippet | `ur acp stdio` (native ACP) or `ur acp serve` (HTTP JSON-RPC; not a streaming transport — see Known limitations). |
 
@@ -128,7 +127,9 @@ rather than leaving it hanging.
 `.ur/ide/chat/` in the workspace (a manifest plus one file per session).
 **UR: Open Chat** can resume a previous session — using the CLI's own
 `--resume` — or start a new one; sessions survive closing and reopening VS
-Code.
+Code. In multi-root workspaces the chat binds to the folder containing the
+active editor, and stale callbacks from a canceled turn cannot mutate a newer
+chat.
 
 **File and selection context.** **UR: Add Current File to Chat** and
 **UR: Add Selection to Chat** attach the active file or selection as explicit
@@ -200,8 +201,9 @@ success it did not observe.
 
 ## Known limitations
 
-- **JetBrains is not implemented.** No JetBrains plugin ships from this
-  repository; see "Supported targets" above.
+- **JetBrains integration is experimental and non-streaming.** It uses the
+  loopback HTTP ACP server and returns the completed synchronous task output;
+  it does not yet render token or tool-call streams.
 - **The lockfile/MCP IDE bridge is Phase 2 and not part of this MVP.** The
   CLI already implements the *client* half of a lockfile-discovered MCP
   connection to a running IDE (`src/utils/ide.ts`), used by the terminal

package/docs/TROUBLESHOOTING.md

@@ -186,6 +186,13 @@ ur ci-loop --command "bun test" --max-attempts 3
 ur test-first detect
 ```
 
+If the runner says "No tests found", check the working directory printed by
+the result and run from the test root or pass it explicitly:
+
+```sh
+ur ci-loop --command "bun test" --cwd ./packages/app --max-attempts 3
+```
+
 ## Integrations
 
 ### Plugin fails to load

package/docs/USAGE.md

@@ -13,7 +13,7 @@ Use interactive mode for iterative coding, debugging, research, and repository e
 Useful options:
 
 ```sh
-ur --model qwen3-coder:480b-cloud
+ur --model qwen2.5-coder:7b
 ur --add-dir ../other-project
 ur --permission-mode ask
 ur --continue
@@ -63,7 +63,7 @@ Ollama router choose from the models exposed by your local Ollama app.
 You can also choose the model for a single session:
 
 ```sh
-ur --model qwen3-coder:480b-cloud
+ur --model qwen2.5-coder:7b
 ur --model qwen2.5-coder:latest
 ```
 
@@ -108,6 +108,10 @@ ur config set base_url <url>
 ur config set provider.fallback ollama
 ```
 
+`provider.fallback` only controls the recovery suggestion printed by provider
+diagnostics. UR does not switch or retry across providers automatically; use
+`ur config set provider <id>` after reviewing the failure.
+
 In the interactive app, `/model` chooses a provider first and then a model from
 that provider only. The saved pair controls the runtime backend for the next
 agent request. There is no cross-provider fallback: OpenAI API does not fall

package/docs/VALIDATION.md

@@ -287,7 +287,7 @@ ur escalate run "refactor the cache layer" --force-oracle --dry-run
 ur test-first --dry-run
 ur safety check --command "rm -rf build"
 ur context-pack scan
-ur ci-loop --command "bun test" --dry-run
+ur ci-loop --command "bun test" --cwd . --dry-run
 ur artifacts capture-tests --command "bun test"
 ```
 

package/docs/providers.md

@@ -36,6 +36,7 @@ multimodal input, external CLI boundary, and sandbox scope:
 | Claude API | API | UR-native | no | yes | yes | yes | UR Bash/File sandbox | `api:anthropic` | `ANTHROPIC_API_KEY` |
 | Gemini API | API | UR-native | no | yes | yes | yes | UR Bash/File sandbox | `api:gemini` | `GEMINI_API_KEY` |
 | OpenRouter | API/router | UR-native | no | yes | yes | yes | UR Bash/File sandbox | `api:openrouter` | `OPENROUTER_API_KEY` |
+| OpenAI-compatible | server/API | UR-native | no | yes | yes | endpoint-dependent | UR Bash/File sandbox | `openai-compatible` | optional `OPENAI_COMPATIBLE_API_KEY`; never reuses `OPENAI_API_KEY` |
 | Ollama | local | UR-native | no | yes | yes | yes* | UR Bash/File sandbox | `ollama` | localhost Ollama runtime |
 | LM Studio | local/server | UR-native | no | yes | yes | yes | UR Bash/File sandbox | `openai-compatible:lmstudio` | local OpenAI-compatible server |
 | llama.cpp | local/server | UR-native | no | yes | yes | yes | UR Bash/File sandbox | `openai-compatible:llama.cpp` | local OpenAI-compatible server |
@@ -106,6 +107,10 @@ ur config set base_url <url>
 ur config set provider.fallback ollama
 ```
 
+The fallback setting is a recovery hint for `ur provider doctor`; it does not
+route a failed request to another provider. Review the failure and use
+`ur config set provider <id>` to switch explicitly.
+
 ## Provider-scoped model selection
 
 UR-Nexus shows providers first, then only models available for the selected provider. This prevents incompatible model/provider pairs and keeps API-key, local/server, subscription, and external app bridge model lists separate. The generic `subscription` entry has no models unless a real independent subscription runtime is configured; UR does not list fake subscription models.
@@ -185,7 +190,7 @@ After selecting a model, the confirmation shows:
 
 → Step 2: Select model
   llama3 · discovered from Ollama · live
-  qwen3-coder:480b-cloud · discovered from Ollama · live
+  qwen2.5-coder:7b · discovered from Ollama · live
   
 → Select: llama3
 
@@ -401,6 +406,7 @@ API providers require explicit user selection and environment keys:
 
 ```sh
 OPENAI_API_KEY=...
+OPENAI_COMPATIBLE_API_KEY=...
 ANTHROPIC_API_KEY=...
 GEMINI_API_KEY=...
 OPENROUTER_API_KEY=...
@@ -414,6 +420,10 @@ ur config set base_url http://localhost:1234/v1
 ur config set model local-model-name
 ```
 
+`OPENAI_COMPATIBLE_API_KEY` is intentionally separate from
+`OPENAI_API_KEY`; selecting an arbitrary compatible base URL never forwards
+the OpenAI credential to that host.
+
 Local/server providers use their normal endpoints:
 
 - Ollama: `http://localhost:11434`

package/documentation/index.html

@@ -44,7 +44,7 @@
     <main id="content" class="content">
       <header class="topbar">
         <div>
-          <p class="eyebrow">Version 1.44.10</p>
+          <p class="eyebrow">Version 1.45.3</p>
           <h1>UR-Nexus Documentation</h1>
           <p class="lead">A practical, tutorial-style reference for installing, configuring, automating, extending, and operating UR-Nexus.</p>
         </div>

package/extensions/jetbrains-ur/README.md

@@ -0,0 +1,22 @@
+# UR for JetBrains (experimental scaffold)
+
+Connects JetBrains IDEs to a running UR-Nexus agent over the local ACP server
+(`ur acp serve --port 9100`). Builds with the IntelliJ Platform Gradle Plugin 2.x (verified: `gradle buildPlugin` produces `build/distributions/jetbrains-ur-<version>.zip` against IDEA 2024.2). Install via Settings → Plugins → ⚙ → Install Plugin from Disk. Mirrors what `extensions/vscode-ur-inline-diffs` does for VS Code.
+
+## What it wires up
+
+- A tool window ("UR Agent") that checks the loopback ACP endpoint without
+  blocking the IDE event thread.
+- An action (Tools → UR: Send Selection) that posts the current selection as
+  a prompt to a project-scoped JSON-RPC session at `/acp`. The current server
+  returns a completed synchronous task result; token streaming is not claimed.
+
+## Build
+
+```
+cd extensions/jetbrains-ur
+JAVA_HOME=$(brew --prefix openjdk@17) gradle buildPlugin   # → build/distributions/*.zip
+```
+
+The heavy lifting stays in UR's ACP server — the plugin is intentionally a
+thin client, so protocol changes land on the CLI side.

package/extensions/jetbrains-ur/build.gradle.kts

@@ -0,0 +1,34 @@
+plugins {
+    id("java")
+    id("org.jetbrains.kotlin.jvm") version "2.0.21"
+    id("org.jetbrains.intellij.platform") version "2.7.2"
+}
+
+group = "dev.urnexus"
+version = "1.45.3"
+
+repositories {
+    mavenCentral()
+    intellijPlatform {
+        defaultRepositories()
+    }
+}
+
+dependencies {
+    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.3")
+    intellijPlatform {
+        intellijIdeaCommunity("2024.2.3")
+    }
+}
+
+intellijPlatform {
+    pluginConfiguration {
+        ideaVersion {
+            sinceBuild.set("242")
+        }
+    }
+}
+
+kotlin {
+    jvmToolchain(17)
+}

package/extensions/jetbrains-ur/settings.gradle.kts

@@ -0,0 +1 @@
+rootProject.name = "jetbrains-ur"

package/extensions/jetbrains-ur/src/main/kotlin/dev/urnexus/SendSelectionAction.kt

@@ -0,0 +1,28 @@
+package dev.urnexus
+
+import com.intellij.openapi.actionSystem.AnAction
+import com.intellij.openapi.actionSystem.AnActionEvent
+import com.intellij.openapi.actionSystem.CommonDataKeys
+import com.intellij.openapi.ui.Messages
+import com.intellij.openapi.progress.ProgressIndicator
+import com.intellij.openapi.progress.ProgressManager
+import com.intellij.openapi.progress.Task
+import com.intellij.openapi.application.ApplicationManager
+
+class SendSelectionAction : AnAction() {
+    override fun actionPerformed(e: AnActionEvent) {
+        val editor = e.getData(CommonDataKeys.EDITOR) ?: return
+        val selection = editor.selectionModel.selectedText ?: return
+        val project = e.project ?: return
+        val client = project.getService(UrAcpClient::class.java)
+        ProgressManager.getInstance().run(object : Task.Backgroundable(project, "Sending selection to UR", true) {
+            override fun run(indicator: ProgressIndicator) {
+                val result = runCatching { client.sendPrompt(selection) }
+                ApplicationManager.getApplication().invokeLater {
+                    result.onSuccess { Messages.showInfoMessage(project, it.take(2000), "UR Agent") }
+                        .onFailure { Messages.showErrorDialog(project, it.message ?: it.toString(), "UR Agent") }
+                }
+            }
+        })
+    }
+}

package/extensions/jetbrains-ur/src/main/kotlin/dev/urnexus/UrAcpClient.kt

@@ -0,0 +1,97 @@
+package dev.urnexus
+
+import com.intellij.openapi.components.Service
+import com.intellij.openapi.project.Project
+import java.net.URI
+import java.net.http.HttpClient
+import java.net.http.HttpRequest
+import java.net.http.HttpResponse
+import java.time.Duration
+import java.util.concurrent.atomic.AtomicLong
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+
+/** Project-scoped JSON-RPC client for UR's HTTP ACP endpoint. */
+@Service(Service.Level.PROJECT)
+class UrAcpClient(private val project: Project) {
+    private val baseUrl = "http://127.0.0.1:9100"
+    private val http = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(5)).build()
+    private val ids = AtomicLong()
+    private val json = Json { ignoreUnknownKeys = true }
+    @Volatile private var initialized = false
+    @Volatile private var sessionId: String? = null
+
+    fun health(): Boolean = try {
+        val req = HttpRequest.newBuilder(URI.create("$baseUrl/healthz"))
+            .timeout(Duration.ofSeconds(5)).GET().build()
+        http.send(req, HttpResponse.BodyHandlers.ofString()).statusCode() == 200
+    } catch (_: Exception) { false }
+
+    @Synchronized
+    fun sendPrompt(prompt: String): String {
+        require(prompt.isNotBlank()) { "Prompt cannot be empty." }
+        ensureSession()
+        val result = rpc("session/prompt", buildJsonObject {
+            put("sessionId", JsonPrimitive(sessionId!!))
+            put("prompt", JsonPrimitive(prompt))
+            put("mode", JsonPrimitive("sync"))
+        }).jsonObject
+        val task = result["task"]?.jsonObject ?: error("ACP response did not include a task.")
+        val status = task["status"]?.jsonPrimitive?.content ?: "unknown"
+        val output = task["result"]?.jsonObject?.get("stdout")?.jsonPrimitive?.content
+        val failure = task["result"]?.jsonObject?.get("stderr")?.jsonPrimitive?.content
+        return output?.takeIf { it.isNotBlank() }
+            ?: failure?.takeIf { it.isNotBlank() }
+            ?: "UR task $status (${task["id"]?.jsonPrimitive?.content ?: "unknown id"})"
+    }
+
+    @Synchronized
+    fun closeSession() {
+        val active = sessionId ?: return
+        try { rpc("session/cancel", buildJsonObject { put("sessionId", JsonPrimitive(active)) }) }
+        finally { sessionId = null }
+    }
+
+    private fun ensureSession() {
+        if (!initialized) {
+            rpc("initialize")
+            initialized = true
+        }
+        if (sessionId == null) {
+            val params = project.basePath?.let { cwd ->
+                buildJsonObject { put("cwd", JsonPrimitive(cwd)) }
+            }
+            sessionId = rpc("session/new", params).jsonObject["sessionId"]?.jsonPrimitive?.content
+                ?: error("ACP session/new response did not include sessionId.")
+        }
+    }
+
+    private fun rpc(method: String, params: JsonObject? = null): JsonElement {
+        val requestId = ids.incrementAndGet()
+        val body = buildJsonObject {
+            put("jsonrpc", JsonPrimitive("2.0"))
+            put("id", JsonPrimitive(requestId))
+            put("method", JsonPrimitive(method))
+            if (params != null) put("params", params)
+        }
+        val request = HttpRequest.newBuilder(URI.create("$baseUrl/acp"))
+            .timeout(Duration.ofMinutes(31))
+            .header("content-type", "application/json")
+            .POST(HttpRequest.BodyPublishers.ofString(body.toString()))
+            .build()
+        val response = http.send(request, HttpResponse.BodyHandlers.ofString())
+        if (response.statusCode() !in 200..299) {
+            error("ACP HTTP ${response.statusCode()}: ${response.body().take(500)}")
+        }
+        val payload = json.parseToJsonElement(response.body()).jsonObject
+        payload["error"]?.jsonObject?.let { rpcError ->
+            error("ACP ${rpcError["code"]?.jsonPrimitive?.content}: ${rpcError["message"]?.jsonPrimitive?.content}")
+        }
+        return payload["result"] ?: error("ACP response did not include a result.")
+    }
+}

package/extensions/jetbrains-ur/src/main/kotlin/dev/urnexus/UrToolWindowFactory.kt

@@ -0,0 +1,27 @@
+package dev.urnexus
+
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.wm.ToolWindow
+import com.intellij.openapi.wm.ToolWindowFactory
+import com.intellij.ui.components.JBScrollPane
+import com.intellij.ui.content.ContentFactory
+import javax.swing.JTextArea
+import com.intellij.openapi.application.ApplicationManager
+
+class UrToolWindowFactory : ToolWindowFactory {
+    override fun createToolWindowContent(project: Project, toolWindow: ToolWindow) {
+        val client = project.getService(UrAcpClient::class.java)
+        val text = JTextArea()
+        text.isEditable = false
+        text.text = "Checking UR ACP server..."
+        val content = ContentFactory.getInstance().createContent(JBScrollPane(text), "", false)
+        toolWindow.contentManager.addContent(content)
+        ApplicationManager.getApplication().executeOnPooledThread {
+            val status = if (client.health())
+                "Connected to UR ACP server (127.0.0.1:9100)."
+            else
+                "UR ACP server not running.\nStart it with: ur acp serve --port 9100"
+            ApplicationManager.getApplication().invokeLater { text.text = status }
+        }
+    }
+}

package/extensions/jetbrains-ur/src/main/resources/META-INF/plugin.xml

@@ -0,0 +1,17 @@
+<idea-plugin>
+  <id>dev.urnexus.jetbrains</id>
+  <name>UR Agent</name>
+  <vendor url="https://github.com/Maitham16/UR">UR-Nexus</vendor>
+  <description>Connects JetBrains IDEs to a local UR-Nexus agent over ACP (ur acp serve).</description>
+  <depends>com.intellij.modules.platform</depends>
+  <extensions defaultExtensionNs="com.intellij">
+    <toolWindow id="UR Agent" anchor="right"
+                factoryClass="dev.urnexus.UrToolWindowFactory"/>
+  </extensions>
+  <actions>
+    <action id="UR.SendSelection" class="dev.urnexus.SendSelectionAction"
+            text="UR: Send Selection" description="Send the current selection to the UR agent">
+      <add-to-group group-id="ToolsMenu" anchor="last"/>
+    </action>
+  </actions>
+</idea-plugin>