ur-agent 1.44.10 → 1.45.2

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

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/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/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.2</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.2"
+
+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>

package/extensions/vscode-ur-inline-diffs/out/extension.js

@@ -62,7 +62,8 @@ var fs = __toESM(require("node:fs"));
 var path = __toESM(require("node:path"));
 var vscode2 = __toESM(require("vscode"));
 function workspaceRoot() {
-  return vscode2.workspace.workspaceFolders?.[0]?.uri.fsPath;
+  const activeUri = vscode2.window.activeTextEditor?.document.uri;
+  return (activeUri ? vscode2.workspace.getWorkspaceFolder(activeUri) : void 0)?.uri.fsPath ?? vscode2.workspace.workspaceFolders?.[0]?.uri.fsPath;
 }
 function diffsRoot(root) {
   return path.join(root, ".ur", "ide", "diffs");
@@ -71,10 +72,34 @@ function manifestPath(root) {
   return path.join(diffsRoot(root), "manifest.json");
 }
 function patchPath(root, bundle) {
-  return path.join(diffsRoot(root), bundle.patchFile);
+  return artifactPath(root, bundle, "patch");
 }
 function metadataPath(root, bundle) {
-  return path.join(diffsRoot(root), bundle.metadataFile);
+  return artifactPath(root, bundle, "metadata");
+}
+var DIFF_ID_PATTERN = /^diff-[1-9][0-9]*$/u;
+function artifactPath(root, bundle, kind) {
+  if (!DIFF_ID_PATTERN.test(bundle.id)) throw new Error(`Invalid UR diff id: ${bundle.id}`);
+  const relative2 = kind === "patch" ? bundle.patchFile : bundle.metadataFile;
+  const expected = kind === "patch" ? `patches/${bundle.id}.patch` : `metadata/${bundle.id}.json`;
+  if (relative2.replaceAll("\\", "/") !== expected) {
+    throw new Error(`Invalid UR diff ${kind} path for ${bundle.id}`);
+  }
+  const rootPath = path.resolve(diffsRoot(root));
+  const target = path.resolve(rootPath, relative2);
+  if (!target.startsWith(`${rootPath}${path.sep}`)) throw new Error(`UR diff ${kind} path escapes the diff store`);
+  return target;
+}
+function isValidBundle(value) {
+  if (!value || typeof value !== "object") return false;
+  const bundle = value;
+  try {
+    patchPath(".", bundle);
+    metadataPath(".", bundle);
+    return true;
+  } catch {
+    return false;
+  }
 }
 function readJson(file, fallback) {
   try {
@@ -90,10 +115,11 @@ function writeJson(file, value) {
 }
 function loadManifest(root) {
   const manifest = readJson(manifestPath(root), { version: 1, diffs: [] });
-  return Array.isArray(manifest.diffs) ? manifest : { version: 1, diffs: [] };
+  return Array.isArray(manifest.diffs) ? { version: 1, diffs: manifest.diffs.filter(isValidBundle) } : { version: 1, diffs: [] };
 }
 function loadBundleMetadata(root, bundle) {
-  return readJson(metadataPath(root, bundle), bundle);
+  const metadata = readJson(metadataPath(root, bundle), bundle);
+  return isValidBundle(metadata) && metadata.id === bundle.id ? metadata : bundle;
 }
 function readPatch(root, bundle) {
   const file = patchPath(root, bundle);
@@ -720,9 +746,9 @@ function languageIdToFence(languageId) {
 }
 function captureEditorSnapshot() {
   const vscode18 = require("vscode");
-  const workspaceRoot2 = vscode18.workspace.workspaceFolders?.[0]?.uri.fsPath;
   const editor = vscode18.window.activeTextEditor;
-  if (!editor) return { workspaceRoot: workspaceRoot2 };
+  if (!editor) return { workspaceRoot: vscode18.workspace.workspaceFolders?.[0]?.uri.fsPath };
+  const workspaceRoot2 = vscode18.workspace.getWorkspaceFolder(editor.document.uri)?.uri.fsPath;
   const absolutePath = editor.document.uri.fsPath;
   const relativePath = workspaceRoot2 ? path2.relative(workspaceRoot2, absolutePath) : absolutePath;
   const activeFile = { path: relativePath, languageId: editor.document.languageId };
@@ -1294,12 +1320,16 @@ var ChatController = class {
   attachments = [];
   status = "idle";
   turnHandle;
+  activeTurnId = 0;
   pendingPermissions = /* @__PURE__ */ new Map();
   // --- commands ---
   async newChat() {
     const root = this.requireWorkspaceRoot();
     if (!root) return;
     this.turnHandle?.cancel();
+    this.activeTurnId++;
+    this.turnHandle = void 0;
+    this.denyAllPending("A new chat was started.");
     this.record = createSession(root);
     this.attachments = [];
     this.status = "idle";
@@ -1418,6 +1448,10 @@ var ChatController = class {
       vscode6.window.showWarningMessage(reason);
       return;
     }
+    if (this.record && snapshot.workspaceRoot !== this.record.session.workspaceRoot) {
+      vscode6.window.showWarningMessage("The active file belongs to a different workspace folder. Start a new chat for that folder.");
+      return;
+    }
     const attachment = kind === "file" ? { kind: "file", file: snapshot.activeFile } : { kind: "selection", selection: snapshot.selection };
     this.attachments.push(attachment);
     this.ensurePanel();
@@ -1437,7 +1471,7 @@ var ChatController = class {
   /** The single pathway every turn goes through — manual sends and editor
    * actions alike. */
   async dispatchTurn(promptText) {
-    const root = this.requireWorkspaceRoot();
+    const root = this.record?.session.workspaceRoot ?? this.requireWorkspaceRoot();
     if (!root) return;
     if (this.status === "running") {
       vscode6.window.showWarningMessage("UR is already running a request. Cancel it first or wait for it to finish.");
@@ -1460,17 +1494,24 @@ var ChatController = class {
     this._onDidChangeState.fire();
     this.panel?.post({ type: "statusChanged", status: this.status });
     const resumeSessionId = this.record.session.cliSessionId;
-    this.turnHandle = runUrTurn(
+    const turnId = ++this.activeTurnId;
+    let exitedSynchronously = false;
+    const handle = runUrTurn(
       { cwd: root, prompt: promptText, resumeSessionId },
       {
-        onMessage: (message) => this.handleStreamMessage(root, sessionId, message),
-        onControlRequest: (request) => this.handlePermissionRequest(request),
-        onExit: (result) => this.handleTurnExit(root, result)
+        onMessage: (message) => this.handleStreamMessage(root, sessionId, turnId, message),
+        onControlRequest: (request) => this.handlePermissionRequest(turnId, request),
+        onExit: (result) => {
+          exitedSynchronously = true;
+          this.handleTurnExit(root, sessionId, turnId, result);
+        }
       },
       { executable: resolveUrCommand({ cwd: root, config: readUrCommandConfig() }) }
     );
+    this.turnHandle = exitedSynchronously ? void 0 : handle;
   }
-  handleStreamMessage(root, sessionId, message) {
+  handleStreamMessage(root, sessionId, turnId, message) {
+    if (turnId !== this.activeTurnId) return;
     if (message.type === "system" && message.subtype === "init" && typeof message.session_id === "string") {
       if (this.record && this.record.session.id === sessionId && !this.record.session.cliSessionId) {
         setCliSessionId(root, sessionId, message.session_id);
@@ -1508,24 +1549,28 @@ var ChatController = class {
     if (!this.record) return;
     this.appendChatMessage(root, this.record.session.id, "status", [{ type: "text", text }]);
   }
-  handlePermissionRequest(request) {
-    return new Promise((resolve2) => {
+  handlePermissionRequest(turnId, request) {
+    if (turnId !== this.activeTurnId) {
+      return Promise.resolve({ behavior: "deny", message: "This chat turn is no longer active." });
+    }
+    return new Promise((resolve3) => {
       const toolName = request.request.tool_name ?? "tool";
       const input = request.request.input ?? {};
-      this.pendingPermissions.set(request.request_id, { resolve: resolve2, toolName, input });
+      this.pendingPermissions.set(request.request_id, { resolve: resolve3, toolName, input, turnId });
       this.panel?.post({ type: "permissionRequest", requestId: request.request_id, toolName, input });
     });
   }
-  handleTurnExit(root, result) {
+  handleTurnExit(root, sessionId, turnId, result) {
+    if (turnId !== this.activeTurnId) return;
     this.turnHandle = void 0;
     this.denyAllPending("The chat turn ended before this request was answered.");
     if (result.canceled) {
       this.status = "canceled";
-      this.appendStatusText(root, "Canceled.");
+      this.appendChatMessage(root, sessionId, "status", [{ type: "text", text: "Canceled." }]);
     } else if (!result.ok) {
       this.status = "error";
       const message = result.error ?? "UR failed to complete this turn.";
-      this.appendStatusText(root, `Error: ${message}`);
+      this.appendChatMessage(root, sessionId, "status", [{ type: "text", text: `Error: ${message}` }]);
       this.panel?.post({ type: "errorBanner", message });
     } else {
       this.status = "idle";
@@ -1535,13 +1580,13 @@ var ChatController = class {
   }
   resolvePermission(requestId, decision) {
     const pending = this.pendingPermissions.get(requestId);
-    if (!pending) return;
+    if (!pending || pending.turnId !== this.activeTurnId) return;
     this.pendingPermissions.delete(requestId);
     pending.resolve(
       decision === "allow" ? { behavior: "allow", updatedInput: pending.input } : { behavior: "deny", message: "User denied this tool call from the UR Chat panel." }
     );
     this.panel?.post({ type: "permissionResolved", requestId });
-    const root = workspaceRoot();
+    const root = this.record?.session.workspaceRoot;
     if (root) this.appendStatusText(root, `${decision === "allow" ? "Allowed" : "Denied"} ${pending.toolName}.`);
   }
   denyAllPending(reason) {

package/extensions/vscode-ur-inline-diffs/package.json

@@ -2,7 +2,7 @@
   "name": "ur-inline-diffs",
   "displayName": "UR Inline Diffs",
   "description": "Review, apply, and reject UR inline diff bundles from .ur/ide/diffs inside VS Code.",
-  "version": "1.44.10",
+  "version": "1.45.2",
   "publisher": "ur-nexus",
   "engines": {
     "vscode": "^1.92.0"