ur-agent 1.45.6 → 1.47.0

package/documentation/app.js

@@ -49,9 +49,9 @@ const featureGroups = [
   },
   {
     title: 'Interoperability',
-    tags: ['MCP', 'plugins', 'A2A', 'SDK'],
-    text: 'MCP servers, plugin marketplaces for skills, templates, validators, language adapters, A2A Agent Card and task server, delegation tokens, and a TypeScript SDK wrapper around headless UR.',
-    commands: ['ur mcp', 'ur plugin', 'ur a2a', 'ur sdk'],
+    tags: ['MCP', 'plugins', 'A2A', 'AG-UI', 'SDK'],
+    text: 'MCP servers, plugin marketplaces, native and cross-client Agent Skills, ACP editor transport, A2A Agent Card/task bindings, a secure AG-UI frontend stream, delegation tokens, and a TypeScript SDK wrapper around headless UR.',
+    commands: ['ur mcp', 'ur plugin', 'ur acp', 'ur a2a', 'ur ag-ui', 'ur sdk'],
   },
   {
     title: 'Providers and auth',
@@ -86,16 +86,23 @@ const commands = [
     name: 'acp',
     category: 'Interop',
     aliases: [],
-    summary: 'Agent Communication Protocol server for IDE extensions: serve, stop, and status.',
-    examples: ['ur acp serve --port 8123', 'ur acp status --json', 'ur acp stop'],
+    summary: 'Run official-SDK ACP v1 over stdio, or manage the distinct UR HTTP JSON-RPC API used by bundled IDE integrations.',
+    examples: ['ur acp stdio', 'ur acp serve --port 8123', 'ur acp status --json'],
   },
   {
     name: 'a2a',
     category: 'Interop',
     aliases: [],
-    summary: 'A2A interoperability utilities: Agent Card, local task server, and delegation tokens.',
+    summary: 'Run negotiated strict A2A v1 JSON-RPC/HTTP+JSON beside the stable-SDK v0.3 binding, or inspect cards and delegation tokens.',
     examples: ['ur a2a card', 'ur a2a serve --dry-run', 'ur a2a token mint --secret "$UR_A2A_DELEGATION_SECRET" --scope coding,review'],
   },
+  {
+    name: 'ag-ui',
+    category: 'Interop',
+    aliases: [],
+    summary: 'Start the secure AG-UI HTTP/SSE adapter for user-facing applications with official events and truthful capability discovery.',
+    examples: ['ur ag-ui serve', 'ur ag-ui serve --allow-origin https://app.example', 'UR_AG_UI_TOKEN="$TOKEN" ur ag-ui serve --host 0.0.0.0'],
+  },
   {
     name: 'bg',
     category: 'Agent Platform',
@@ -718,6 +725,11 @@ const examples = [
     text: 'Expose Agent Card discovery and token-gated task execution.',
     code: 'ur a2a card\nur a2a serve --host 127.0.0.1 --port 8765 --dry-run',
   },
+  {
+    title: 'AG-UI frontend stream',
+    text: 'Expose the official-schema SSE adapter on loopback, or require a bearer token and exact browser origin for network use.',
+    code: 'ur ag-ui serve\nUR_AG_UI_TOKEN="$TOKEN" ur ag-ui serve --host 0.0.0.0 --allow-origin https://app.example',
+  },
   {
     title: 'Delegated A2A token',
     text: 'Mint an attenuated token scoped to selected skills.',

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.47.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>
@@ -71,7 +71,7 @@
           </article>
           <article>
             <strong>Agent platform</strong>
-            <span>Workflows, patterns, crews, goals, evals, memory, knowledge, A2A, provenance, and templates are first-class commands.</span>
+            <span>Workflows, patterns, crews, goals, evals, memory, knowledge, ACP, A2A, AG-UI, provenance, and templates are first-class commands.</span>
           </article>
           <article>
             <strong>Plugin marketplace</strong>
@@ -158,12 +158,14 @@ ur provider doctor agy</code></pre>
 ur config set provider openai-api
 ur config set base_url http://localhost:11434/v1
 ur config set model qwen3-coder:480b-cloud
-ur config set provider.fallback ollama</code></pre>
-            <p>API providers require explicit selection and read keys from a key stored via <code>ur connect</code> (OS keychain) or from environment variables. Local providers include Ollama, LM Studio, llama.cpp, and vLLM.</p>
+ur config set provider.fallback ollama
+ur config set openai_transport responses
+ur config set responses.store false</code></pre>
+            <p>API providers require explicit selection and read keys from a key stored via <code>ur connect</code> (OS keychain) or from environment variables. OpenAI Responses is opt-in and privacy-first; Chat Completions remains the default. Local providers include Ollama, LM Studio, llama.cpp, and vLLM.</p>
           </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.47.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>
@@ -298,13 +300,14 @@ ur test-first install</code></pre>
 ur safety check --command "rm -rf build"
 ur context-pack scan
 ur context-pack remember --decision "Use manifest commands first"
+ur context-pack memory verify
 ur context-pack compress</code></pre>
           </article>
 
           <article>
             <h3>Start the ACP server and run a prompt pool</h3>
             <ol>
-              <li>Start the Agent Communication Protocol server for IDE extensions.</li>
+              <li>Start the Agent Client Protocol server for IDE extensions.</li>
               <li>Run one or more prompts in non-interactive mode with concurrency.</li>
               <li>Capture per-prompt outputs to a directory.</li>
             </ol>
@@ -314,6 +317,18 @@ ur exec "add tests for the parser" --concurrency 4 --json
 ur exec --file prompts.jsonl --output-dir ./outputs --dry-run</code></pre>
           </article>
 
+          <article>
+            <h3>Connect a user-facing app with AG-UI</h3>
+            <ol>
+              <li>Start the official-schema HTTP/SSE adapter on loopback.</li>
+              <li>Inspect its truthful capability document.</li>
+              <li>For browser or network use, require a bearer token and exact allowed origin.</li>
+            </ol>
+            <pre><code>ur ag-ui serve
+curl http://127.0.0.1:8977/ag-ui/capabilities
+UR_AG_UI_TOKEN="$TOKEN" ur ag-ui serve --host 0.0.0.0 --allow-origin https://app.example</code></pre>
+          </article>
+
           <article>
             <h3>Use a multi-agent pattern</h3>
             <ol>
@@ -477,8 +492,9 @@ ur safety check --command "rm -rf build"</code></pre>
             <h3>Project context</h3>
             <pre><code>ur context-pack scan
 ur context-pack remember --constraint "Run command evidence before success claims"
+ur context-pack memory verify
 ur context-pack compress</code></pre>
-            <p>Context packs summarize architecture from manifests and preserve task decisions, constraints, commands, and diffs under <code>.ur/context</code>.</p>
+            <p>Context packs summarize architecture and preserve provenance-rich, hash-chained task memory under <code>.ur/context</code>, with verification, quarantine, and rollback recovery.</p>
           </article>
           <article>
             <h3>Verifier</h3>
@@ -493,9 +509,12 @@ UR_VERIFIER_AUTO_SUBAGENT=1</code></pre>
             <h3>MCP and plugins</h3>
             <pre><code>ur mcp list
 ur mcp add-json local-tools '{"command":"node","args":["server.js"]}'
+ur mcp serve-http --port 8976
+ur skill verify &lt;name-or-directory&gt;
+ur ag-ui serve --help
 ur plugin list
 ur plugin install &lt;plugin&gt;</code></pre>
-            <p>MCP servers and marketplace plugins expand tools, executable skills, templates, validators, language adapters, and review workflows. Treat them as trusted code.</p>
+            <p>The opt-in stateless MCP HTTP adapter exposes negotiated Tasks and Apps. Portable skills load from native and cross-client roots with strict validation and Ed25519 provenance. AG-UI provides a bounded, opt-in frontend stream. Treat MCP servers and plugins as trusted code.</p>
           </article>
           <article>
             <h3>IDE inline diffs</h3>

package/examples/agent_features.md

@@ -56,6 +56,7 @@ ur safety check --command "rm -rf build"
 ur context-pack scan
 ur context-pack remember --decision "Use package scripts before ad hoc commands"
 ur context-pack remember --constraint "Never expose secret values"
+ur context-pack memory verify
 ur context-pack compress
 ```
 
@@ -90,3 +91,20 @@ Run the opt-in A2A server on loopback:
 ur a2a serve --dry-run
 curl http://127.0.0.1:8765/healthz
 ```
+
+Inspect signed skills and the stateless MCP adapter:
+
+```sh
+ur skill verify <name-or-directory>
+ur mcp serve-http --help
+```
+
+Inspect the provider-free AG-UI surface and cross-client skill discovery:
+
+```sh
+ur ag-ui serve --help
+ur skill verify <name-or-directory>
+```
+
+Portable skills may be placed in `.agents/skills/<name>/SKILL.md`; project
+skills override user skills, and native `.ur/skills/` wins at the same scope.

package/examples/agent_trends.md

@@ -3,11 +3,16 @@
 - Run `ur agent-trends` for a human-readable coverage report.
 - Run `ur agent-trends --json` when another tool needs structured coverage data.
 - Run `ur a2a card` to print UR's Agent Card metadata for A2A discovery.
+- Run `ur ag-ui serve --help` to inspect the user-facing HTTP/SSE adapter
+  without starting a model call.
 - Run `ur test-first --dry-run` to preview the detected compile/test/lint
   evidence loop for the current project.
 - Run `ur safety check --command "rm -rf build"` to preview command permission
   class, destructive approval, and sandbox posture.
 - Run `ur context-pack scan` and `ur context-pack compress` to preserve
   manifest-derived architecture context and task memory.
+- Run `ur context-pack memory verify`, `ur skill verify <name>`, and
+  `ur mcp serve-http --help`, and `ur ag-ui serve --help` to inspect the v1.47 integrity and protocol
+  surfaces without making a paid model call.
 - Use `/agent-trends` inside a session before planning upgrades to local
   runtime, MCP, A2A, memory, browser, eval, identity, or provenance workflows.

package/examples/mcp.md

@@ -5,3 +5,7 @@
   their tools into the registry and runs them through the same approval +
   evidence-ledger path as built-in tools (so MCP calls appear in `/evidence`).
 - Risky MCP tools require approval before they run.
+- `ur mcp serve` exposes the fail-closed stdio server. The separate
+  `UR_MCP_HTTP_TOKEN='<secret>' ur mcp serve-http` command starts the opt-in
+  stateless MCP 2026 HTTP surface with negotiated Tasks and a self-contained
+  App; off-loopback use requires bearer authentication.

package/examples/memory.md

@@ -9,7 +9,10 @@
   `.ur/context/architecture.md` from package scripts, instruction files,
   `.ur/verify.json`, and safety config.
 - `ur context-pack remember --decision|--constraint|--command|--diff|--note`
-  appends durable task memory to `.ur/context/task-memory.jsonl`; `compress`
-  writes `.ur/context/compressed.md`.
+  appends provenance-rich, hash-chained task memory to
+  `.ur/context/task-memory.jsonl`; `ur context-pack memory verify|quarantine`
+  checks or repairs a corrupt tail, `memory rollback --to <entry-id>` preserves
+  a private backup before truncation, and `compress` writes
+  `.ur/context/compressed.md`.
 - `/ur-init` scaffolds the `.ur/` asset folder (docs, superpowers, brainstorming,
   memory, prompts).

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.47.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