ur-agent 1.45.6 → 1.46.0

package/docs/IDE.md

@@ -13,8 +13,8 @@ stated honestly — nothing here claims support that does not exist:
   below. Ships to VS Code, Cursor, and Windsurf (one extension; Cursor and
   Windsurf are VS Code forks). This is the integration everything else on
   this page is compared against.
-- **Stdio ACP** (`ur acp stdio`) — the real, spec-compliant
-  [Agent Client Protocol](ACP.md) over stdio, used by Zed and ACP-capable
+- **Stdio ACP** (`ur acp stdio`) — stable ACP v1 over stdio, backed by the
+  official TypeScript SDK and used by Zed and ACP-capable
   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.
@@ -33,14 +33,14 @@ 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 | bundled experimental plugin + HTTP ACP | manual zip install | Project-scoped JSON-RPC session and Send Selection action; synchronous ACP task result, not token streaming. |
+| JetBrains | bundled experimental plugin + UR HTTP JSON-RPC | manual zip install | Project-scoped JSON-RPC session and Send Selection action; synchronous task result, not 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). |
+| Generic ACP | stdio ACP | snippet | `ur acp stdio` is the native ACP transport. `ur acp serve` is a separate UR-specific HTTP API. |
 
 ## Commands
 
 ```sh
-ur ide status               # workspace, ACP server, provider/model, sandbox/verifier mode, plugin count, warnings
+ur ide status               # workspace, UR HTTP server, provider/model, sandbox/verifier mode, plugin count, warnings
 ur ide doctor                # pass/warn/fail checks; reports missing config clearly
 ur ide config <editor>       # print setup + config snippet for the chosen editor
 ur ide open                  # open the current project/worktree in a detected IDE
@@ -52,7 +52,7 @@ ur ide diff approve|reject <id>
 `ur ide config` targets: `vscode`, `cursor`, `windsurf`, `zed`, `jetbrains`,
 `neovim`, `generic-acp` (aliases like `nvim`, `intellij`, `code` also resolve).
 
-`ur ide status` reports the active workspace, whether the ACP server is
+`ur ide status` reports the active workspace, whether the UR HTTP compatibility server is
 running and on which port, the active provider/model and runtime backend,
 sandbox mode, verifier mode, the number of loaded plugins, and any warnings.
 Add `--json` for machine-readable output — this is the same JSON surface the
@@ -150,9 +150,12 @@ tasks (`ur bg list --json`) together in one place, with its own refresh
 button and a clear empty state when there is nothing captured yet. Diff rows
 support the same Open/Apply/Reject/Comment actions as the Inline Diffs view
 (routed through the CLI, as described above). Background task rows are
-read-only in this release — click one to open its log file; starting or
-canceling a task from the panel is not implemented yet, use
-`ur bg run|kill` from a terminal.
+actionable: **Start Background Task** offers isolated-worktree (recommended),
+offline isolated-worktree, and current-workspace modes, confirms before
+launch, and never enables permission bypass or PR publishing. Active tasks
+can be canceled from their context menu. Opening a task retrieves the latest
+2,000 log lines through `ur bg logs`, so the extension never trusts an
+arbitrary manifest path as a file to open.
 
 ### Agent status card
 
@@ -170,7 +173,8 @@ CLI does not report renders as the literal word **unknown** — never a guess.
 action the extension exposes: New Chat, Open Chat, Explain Selection, Fix
 Selection, Generate Tests, Review Current Diff, Run Verifier, Provider
 Status, Agent Status, Agent Options, Open Settings, Open Docs, Open
-Artifacts, Run Spec, Run Workflow, and Refresh IDE Actions.
+Artifacts, Run Spec, Run Workflow, Start Background Task, and Refresh IDE
+Actions.
 
 ### Agent options panel
 
@@ -202,8 +206,9 @@ success it did not observe.
 ## Known limitations
 
 - **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.
+  loopback UR HTTP JSON-RPC server and returns the completed synchronous task output;
+  it does not yet render token or tool-call streams. Canceling the IDE progress
+  action does propagate to the active server-side session.
 - **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
@@ -211,20 +216,18 @@ success it did not observe.
   terminal-hosted `ur` session. The VS Code extension's chat panel does not
   use this bridge — it talks to UR entirely through the `stream-json`
   subprocess contract described above.
-- **The ACP HTTP server (`ur acp serve`) is not the VS Code chat streaming
-  transport.** It is a separate, non-streaming JSON-RPC endpoint intended for
+- **The UR HTTP server (`ur acp serve`) is neither an ACP binding nor the VS
+  Code chat streaming transport.** It is a separate, non-streaming JSON-RPC endpoint intended for
   scripts and other clients; the VS Code extension does not route chat
   through it, and `ur acp stdio` (used by Zed and ACP Neovim clients) is
   unaffected by any of the VS Code work described here.
-- **Background task actions are read-only** in the Actions panel — no start
-  or cancel from the panel yet.
 - **Run Spec / Run Workflow** open chat with a prompt asking UR to list and
   run the relevant items, rather than shelling out directly — `ur spec` and
   `ur workflow` are full agentic commands, not one-shot JSON lookups.
 
 ## Troubleshooting
 
-- **`ur ide status` shows "ACP server: not running":** start it with
+- **`ur ide status` shows "UR HTTP server: not running":** start it with
   `ur acp serve` (HTTP) or `ur acp stdio` (for ACP editors).
 - **No IDE detected:** ensure the editor is running with the UR extension/plugin
   installed, or generate config with `ur ide config <editor>`.

package/docs/TROUBLESHOOTING.md

@@ -208,12 +208,14 @@ ur plugin list
 
 ### ACP / editor connection issues
 
-- Likely cause: the ACP server is not running, or the editor config block is
-  missing.
-- Fix: check status, regenerate the editor config, and run the IDE doctor.
+- Likely cause: the native stdio command/config is wrong, or the optional UR
+  HTTP server used by JetBrains is not running.
+- Fix: verify the stdio command is registered, check HTTP status when relevant,
+  regenerate the editor config, and run the IDE doctor.
 
 ```sh
 ur acp status
+ur acp stdio --help
 ur ide doctor
 ur ide config zed    # or vscode, cursor, windsurf, jetbrains, neovim
 ```

package/docs/USAGE.md

@@ -268,7 +268,7 @@ UR includes slash commands and CLI subcommands for common workflows:
   after one attempt and reports how to correct `--cwd`.
 - `ur artifacts ...` to capture reviewable diffs, test runs, notes, and feedback
 - `ur ide diff ...` to capture editor-readable inline diff bundles
-- `ur acp ...` to start/stop/status the Agent Communication Protocol server for IDE extensions
+- `ur acp stdio` for the official-SDK Agent Client Protocol v1 editor transport, and `ur acp serve|stop|status` for the separate UR HTTP JSON-RPC API
 - `ur exec ...` to run prompts in non-interactive mode with optional concurrency
 - `ur eval run ...` to run a suite, grade results, and capture execution metrics
 - `ur eval report ...` to show a saved report or write a single-suite dashboard
@@ -292,7 +292,7 @@ UR includes slash commands and CLI subcommands for common workflows:
 - `ur trigger ...` to parse GitHub/Slack webhook payloads and optionally launch a headless run
 - `ur agent-templates ...`, `ur agent-task ...`, `ur agent-inspect`, `ur agent-features`, and `ur agent-trends` for agent template, PR handoff, timeline, and coverage utilities
 - `ur role-mode ...` to install built-in Architect, Code, Debug, and Ask role modes
-- `ur a2a ...` for Agent Card metadata, delegation tokens, and the opt-in A2A task server
+- `ur a2a ...` for Agent Card metadata, issuer-signed delegation tokens, the stable A2A v0.3 JSON-RPC binding, and UR compatibility task routes
 - `ur sdk ...` to scaffold TS/Python headless SDK examples
 - `ur doctor` to inspect CLI health
 - `ur update` or `ur upgrade` to check for updates

package/docs/VALIDATION.md

@@ -19,7 +19,7 @@ You need:
 
 ```sh
 ur --version
-# expected for this release: "1.45.6 (UR-Nexus)"
+# expected for this release: "1.46.0 (UR-Nexus)"
 ```
 
 ## 0.1 First-workspace model selection (1.45.4)

package/docs/providers.md

@@ -465,4 +465,8 @@ Common knobs:
 PROVIDER_SMOKE_TIMEOUT_MS=30000
 PROVIDER_SMOKE_MAX_RETRIES=0
 PROVIDER_SMOKE_TOOL_CALLS=1
+PROVIDER_SMOKE_OUTPUT=/tmp/ur-provider-smoke.json # --json only
 ```
+
+Without `PROVIDER_SMOKE_OUTPUT`, `--json` also writes the latest report to
+`diagnostics/provider-smoke/latest.json`.

package/documentation/index.html

@@ -44,7 +44,7 @@
     <main id="content" class="content">
       <header class="topbar">
         <div>
-          <p class="eyebrow">Version 1.45.6</p>
+          <p class="eyebrow">Version 1.46.0</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>
@@ -163,7 +163,7 @@ ur config set provider.fallback ollama</code></pre>
           </article>
           <article>
             <h3>Status bar and updates</h3>
-            <pre><code>Ollama | llama3 | ask | main | update 1.45.6 available</code></pre>
+            <pre><code>Ollama | llama3 | ask | main | update 1.46.0 available</code></pre>
             <p>The interactive status bar shows only important runtime state: provider, model, mode, branch, active tasks, checks status when known, and update availability. It is hidden in CI, dumb terminals, and print mode.</p>
           </article>
           <article>

package/extensions/jetbrains-ur/README.md

@@ -1,22 +1,29 @@
 # 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.
+Connects JetBrains IDEs to a running UR-Nexus agent over the local UR HTTP
+JSON-RPC server (`ur acp serve --port 9100`). This endpoint is a UR-specific
+compatibility API, not an Agent Client Protocol transport binding. The plugin
+builds with IntelliJ Platform Gradle Plugin 2.18 and IDEA 2024.3. The official
+Plugin Verifier reports the artifact compatible with IntelliJ IDEA 2024.3,
+2025.1, and 2025.2. Install the `buildPlugin` zip via Settings → Plugins → ⚙ →
+Install Plugin from Disk.
 
 ## What it wires up
 
-- A tool window ("UR Agent") that checks the loopback ACP endpoint without
+- A tool window ("UR Agent") that checks the loopback UR 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.
+  The IDE progress action is cancelable and forwards cancellation to the active
+  server-side session instead of merely dismissing the progress UI.
 
 ## Build
 
 ```
 cd extensions/jetbrains-ur
-JAVA_HOME=$(brew --prefix openjdk@17) gradle buildPlugin   # → build/distributions/*.zip
+JAVA_HOME=$(brew --prefix openjdk@21) gradle buildPlugin   # → build/distributions/*.zip
 ```
 
-The heavy lifting stays in UR's ACP server — the plugin is intentionally a
+The heavy lifting stays in UR's HTTP server — the plugin is intentionally a
 thin client, so protocol changes land on the CLI side.

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

@@ -1,11 +1,13 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmDefaultMode
+
 plugins {
     id("java")
-    id("org.jetbrains.kotlin.jvm") version "2.0.21"
-    id("org.jetbrains.intellij.platform") version "2.7.2"
+    id("org.jetbrains.kotlin.jvm") version "2.4.0"
+    id("org.jetbrains.intellij.platform") version "2.18.1"
 }
 
 group = "dev.urnexus"
-version = "1.45.6"
+version = "1.46.0"
 
 repositories {
     mavenCentral()
@@ -14,21 +16,35 @@ repositories {
     }
 }
 
+configurations.named("runtimeClasspath") {
+    // IntelliJ provides these at runtime. Scoping the exclusions here keeps
+    // them out of the distributable without breaking Gradle's compiler tools.
+    exclude(group = "org.jetbrains.kotlin", module = "kotlin-stdlib")
+    exclude(group = "org.jetbrains.kotlin", module = "kotlin-stdlib-common")
+    exclude(group = "org.jetbrains", module = "annotations")
+}
+
 dependencies {
     implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.3")
     intellijPlatform {
-        intellijIdeaCommunity("2024.2.3")
+        intellijIdeaCommunity("2024.3.7.1")
     }
 }
 
 intellijPlatform {
     pluginConfiguration {
         ideaVersion {
-            sinceBuild.set("242")
+            sinceBuild.set("243")
         }
     }
 }
 
 kotlin {
-    jvmToolchain(17)
+    jvmToolchain(21)
+    compilerOptions {
+        // IntelliJ's Java interfaces provide JVM default methods. Kotlin's
+        // compatibility mode would otherwise emit synthetic overrides for
+        // platform-internal methods and make the verifier reject the plugin.
+        jvmDefault.set(JvmDefaultMode.NO_COMPATIBILITY)
+    }
 }

package/extensions/jetbrains-ur/gradle.properties

@@ -0,0 +1 @@
+kotlin.stdlib.default.dependency=false

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

@@ -1 +1,5 @@
+plugins {
+    id("org.gradle.toolchains.foojay-resolver-convention") version "1.0.0"
+}
+
 rootProject.name = "jetbrains-ur"

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

@@ -8,8 +8,17 @@ import com.intellij.openapi.progress.ProgressIndicator
 import com.intellij.openapi.progress.ProgressManager
 import com.intellij.openapi.progress.Task
 import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.progress.ProcessCanceledException
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.locks.LockSupport
 
 class SendSelectionAction : AnAction() {
+    override fun update(e: AnActionEvent) {
+        val selection = e.getData(CommonDataKeys.EDITOR)?.selectionModel?.selectedText
+        e.presentation.isEnabledAndVisible = e.project != null && !selection.isNullOrBlank()
+    }
+
     override fun actionPerformed(e: AnActionEvent) {
         val editor = e.getData(CommonDataKeys.EDITOR) ?: return
         val selection = editor.selectionModel.selectedText ?: return
@@ -17,12 +26,37 @@ class SendSelectionAction : AnAction() {
         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") }
+                indicator.isIndeterminate = true
+                val finished = AtomicBoolean(false)
+                val cancellationMonitor = CompletableFuture.runAsync {
+                    while (!finished.get()) {
+                        if (
+                            indicator.isCanceled &&
+                            runCatching { client.cancelPrompt() }.getOrDefault(false)
+                        ) return@runAsync
+                        LockSupport.parkNanos(100_000_000)
+                        if (Thread.currentThread().isInterrupted) return@runAsync
+                    }
+                }
+                try {
+                    indicator.checkCanceled()
+                    val result = client.sendPrompt(selection)
+                    indicator.checkCanceled()
+                    ApplicationManager.getApplication().invokeLater {
+                        Messages.showInfoMessage(project, result.take(2000), "UR Agent")
+                    }
+                } catch (cancelled: ProcessCanceledException) {
+                    runCatching { client.cancelPrompt() }
+                    throw cancelled
+                } catch (error: Exception) {
+                    ApplicationManager.getApplication().invokeLater {
+                        Messages.showErrorDialog(project, error.message ?: error.toString(), "UR Agent")
+                    }
+                } finally {
+                    finished.set(true)
+                    cancellationMonitor.cancel(true)
                 }
             }
-        })
+        }.setCancelText("Cancel UR prompt"))
     }
 }

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

@@ -7,6 +7,7 @@ import java.net.http.HttpClient
 import java.net.http.HttpRequest
 import java.net.http.HttpResponse
 import java.time.Duration
+import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.atomic.AtomicLong
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonElement
@@ -16,12 +17,14 @@ 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. */
+/** Project-scoped JSON-RPC client for UR's HTTP compatibility 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 promptInFlight = AtomicBoolean(false)
+    private val sessionLock = Any()
     private val json = Json { ignoreUnknownKeys = true }
     @Volatile private var initialized = false
     @Volatile private var sessionId: String? = null
@@ -32,32 +35,56 @@ class UrAcpClient(private val project: Project) {
         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"))
+        require(prompt.length <= 64_000 && !prompt.contains('\u0000')) {
+            "Prompt must contain at most 64,000 characters and no NUL bytes."
+        }
+        check(promptInFlight.compareAndSet(false, true)) {
+            "A UR prompt is already running for this project."
+        }
+        try {
+            val active = ensureSession()
+            val result = rpc(
+                "session/prompt",
+                buildJsonObject {
+                    put("sessionId", JsonPrimitive(active))
+                    put("prompt", JsonPrimitive(prompt))
+                    put("mode", JsonPrimitive("sync"))
+                },
+                Duration.ofMinutes(121),
+            ).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"})"
+        } finally {
+            promptInFlight.set(false)
+        }
+    }
+
+    fun cancelPrompt(): Boolean {
+        val active = sessionId ?: return false
+        val result = rpc("session/cancel", buildJsonObject {
+            put("sessionId", JsonPrimitive(active))
         }).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"})"
+        return result["canceled"]?.jsonPrimitive?.content?.toBooleanStrictOrNull() ?: false
     }
 
-    @Synchronized
     fun closeSession() {
         val active = sessionId ?: return
-        try { rpc("session/cancel", buildJsonObject { put("sessionId", JsonPrimitive(active)) }) }
-        finally { sessionId = null }
+        try { rpc("session/close", buildJsonObject { put("sessionId", JsonPrimitive(active)) }) }
+        finally {
+            synchronized(sessionLock) {
+                if (sessionId == active) sessionId = null
+            }
+        }
     }
 
-    private fun ensureSession() {
+    private fun ensureSession(): String = synchronized(sessionLock) {
         if (!initialized) {
             rpc("initialize")
             initialized = true
@@ -69,9 +96,14 @@ class UrAcpClient(private val project: Project) {
             sessionId = rpc("session/new", params).jsonObject["sessionId"]?.jsonPrimitive?.content
                 ?: error("ACP session/new response did not include sessionId.")
         }
+        sessionId!!
     }
 
-    private fun rpc(method: String, params: JsonObject? = null): JsonElement {
+    private fun rpc(
+        method: String,
+        params: JsonObject? = null,
+        timeout: Duration = Duration.ofSeconds(30),
+    ): JsonElement {
         val requestId = ids.incrementAndGet()
         val body = buildJsonObject {
             put("jsonrpc", JsonPrimitive("2.0"))
@@ -80,7 +112,7 @@ class UrAcpClient(private val project: Project) {
             if (params != null) put("params", params)
         }
         val request = HttpRequest.newBuilder(URI.create("$baseUrl/acp"))
-            .timeout(Duration.ofMinutes(31))
+            .timeout(timeout)
             .header("content-type", "application/json")
             .POST(HttpRequest.BodyPublishers.ofString(body.toString()))
             .build()

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

@@ -3,6 +3,7 @@ package dev.urnexus
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.wm.ToolWindow
 import com.intellij.openapi.wm.ToolWindowFactory
+import com.intellij.openapi.wm.ToolWindowManager
 import com.intellij.ui.components.JBScrollPane
 import com.intellij.ui.content.ContentFactory
 import javax.swing.JTextArea
@@ -13,15 +14,17 @@ class UrToolWindowFactory : ToolWindowFactory {
         val client = project.getService(UrAcpClient::class.java)
         val text = JTextArea()
         text.isEditable = false
-        text.text = "Checking UR ACP server..."
+        text.text = "Checking UR HTTP 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)."
+                "Connected to UR HTTP 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 }
+                "UR HTTP server not running.\nStart it with: ur acp serve --port 9100"
+            ToolWindowManager.getInstance(project).invokeLater {
+                if (!project.isDisposed) text.text = status
+            }
         }
     }
 }

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

@@ -2,7 +2,7 @@
   <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>
+  <description>Connects JetBrains IDEs to a local UR-Nexus agent over its loopback HTTP JSON-RPC API (ur acp serve).</description>
   <depends>com.intellij.modules.platform</depends>
   <extensions defaultExtensionNs="com.intellij">
     <toolWindow id="UR Agent" anchor="right"

package/extensions/vscode-ur-inline-diffs/README.md

@@ -68,8 +68,12 @@ tasks (`ur bg list`) in one place. Supported actions on a diff bundle:
 - **Reject**, via `ur ide diff reject`;
 - add a comment that writes back through `ur ide diff comment`.
 
-Background task rows in the Actions panel are read-only for now — click one
-to open its log file.
+The Actions title bar can start a background task in an isolated worktree
+(recommended), an offline isolated worktree, or the current workspace. UR
+asks for explicit confirmation, does not enable permission bypass or PR
+publishing, and exposes cancellation only for queued/running rows. Opening a
+row retrieves a bounded log tail through `ur bg logs` instead of trusting a
+manifest-supplied file path.
 
 ## Status and options