ur-agent 1.36.1 → 1.37.0

package/docs/IDE.md

@@ -1,44 +1,63 @@
 # IDE Integration
 
-UR integrates with editors through three mechanisms, chosen per editor and stated
-honestly — nothing claims support it does not have:
-
-- **Native extension** — a UR extension/plugin runs inside the editor (VS Code
-  family, JetBrains). UR connects to it via the `/ide` flow.
-- **Stdio ACP** — the editor launches UR as an [Agent Client Protocol](ACP.md)
-  agent over stdio (`ur acp stdio`). Used by Zed and ACP-capable Neovim clients.
+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.
+
+Other editors connect through different mechanisms, chosen per editor and
+stated honestly — nothing here claims support that does not exist:
+
+- **VS Code extension** — the professional integration described in full
+  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
+  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.
 
 ## Supported targets
 
-| Editor | Mechanism | Auto config | Apply/reject | Notes |
-| --- | --- | --- | --- | --- |
-| VS Code | native extension | `.vscode/settings.json` | via UR extension | Install the UR Inline Diffs extension. |
-| Cursor | native extension (VS Code fork) | `.vscode/settings.json` | via UR extension | Same extension as VS Code. |
-| Windsurf | native extension (VS Code fork) | `.vscode/settings.json` | via UR extension | Same extension as VS Code. |
-| Zed | stdio ACP | `.zed/settings.json` | in-editor (ACP) | Real Agent Client Protocol over stdio. |
-| JetBrains | manual plugin | none | via plugin | Install the UR JetBrains plugin, then `/ide`. |
-| Neovim | stdio ACP | snippet | client-dependent | Requires a third-party ACP client plugin. |
-| Generic ACP | stdio ACP / HTTP | snippet | client-dependent | `ur acp stdio` (native ACP) or `ur acp serve` (HTTP JSON-RPC). |
+| Editor | Mechanism | Auto config | Notes |
+| --- | --- | --- | --- |
+| VS Code | UR Inline Diffs extension | `.vscode/settings.json` | Full chat, diff, actions, status, and search integration — see below. |
+| 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. |
+| 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). |
 
 ## Commands
 
 ```sh
-ur ide status               # workspace, ACP server, provider/model, 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
-ur ide diff capture         # capture the current diff as a review bundle
-ur ide diff list|show <id>  # inspect captured bundles
+ur ide status               # workspace, ACP 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
+ur ide diff capture          # capture the current diff as a review bundle
+ur ide diff list|show <id>   # inspect captured bundles
 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 running
-and on which port, the active provider/model and runtime backend, the number of
-loaded plugins, and any warnings. Add `--json` for machine-readable output.
+`ur ide status` reports the active workspace, whether the ACP 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
+VS Code extension's status card and actions panel read from.
 
 ## Patch / diff workflow
 
@@ -47,23 +66,147 @@ under `.ur/ide/diffs/` (`ur ide diff capture`), then previewed and explicitly
 applied or rejected:
 
 - **CLI:** `ur ide diff show <id>`, `ur ide diff approve <id>`, `ur ide diff reject <id>`.
-- **VS Code:** the UR Inline Diffs view lists bundles; right-click a bundle to
-  Open (preview), Apply (`git apply`, with a confirmation prompt), Reject, or
-  Comment. Applying is always an explicit, confirmed action.
+- **VS Code:** the **Inline Diffs** view (and the **Actions** view — they show
+  the same bundles) lists bundles; right-click one to Open (preview), Apply,
+  Reject, or Comment. Apply asks for confirmation, runs `git apply`, then
+  records the approval through `ur ide diff approve` — the same command the
+  terminal workflow uses, so the status VS Code shows always matches what
+  `ur ide diff list` reports. The extension never writes a diff status value
+  the CLI does not recognize.
 
 ## VS Code extension
 
-The bundled `UR Inline Diffs` extension (`extensions/vscode-ur-inline-diffs`)
-provides:
+The bundled **UR Inline Diffs** extension is the professional IDE integration
+for VS Code, Cursor, and Windsurf. It adds a UR container to the Activity Bar
+with two views, **Inline Diffs** and **Actions**, plus a chat panel, a status
+card, an agent options panel, and a searchable command palette.
+
+Install it with `ur ide install` (offers the bundled VSIX) or from the
+packaged `.vsix`. The extension is bundled inside this repository and
+packaged as a local VSIX when installed from UR-AGENT; the public install
+path does not depend on an unpublished marketplace extension ID. Every
+feature below requires the UR CLI on your `PATH` — the extension calls `ur`
+as a local subprocess and never talks to a model provider or network service
+directly.
+
+### Chat panel
 
-- a tree view of captured diff bundles;
-- a read-only webview preview of each patch and its comments;
-- **Apply** (confirmed `git apply`) and **Reject** actions;
-- **UR: Show Status**, which runs `ur ide status` and prints provider/model and
-  plugin information to the UR output channel.
+**UR: New Chat** and **UR: Open Chat** open a chat panel that streams
+responses over the same headless contract the CLI itself uses for scripted
+runs:
+
+```
+ur -p --output-format stream-json --verbose --permission-prompt-tool stdio [--resume <id>] "<prompt>"
+```
 
-Install it with `ur ide install` (offers the bundled VSIX) or from the packaged
-`.vsix`. Apply/reject and status require the UR CLI on your `PATH`.
+Output is NDJSON — one JSON object per line. Assistant text and tool-use/
+tool-result blocks render as they arrive; nothing is buffered and dumped only
+at the end. If the underlying `ur` process exits with an error, the panel
+shows an error banner — it never fabricates a success message when the run
+failed.
+
+**Permission prompts.** When a turn wants to use a tool that needs approval,
+UR emits a `control_request` message in the same stream. The chat panel shows
+an inline Allow/Deny prompt and writes the decision back as a
+`control_response` on the child process's stdin. The default posture is to
+ask, not to silently auto-approve; canceling a request denies it safely
+rather than leaving it hanging.
+
+**Session persistence.** Each chat is a session persisted under
+`.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.
+
+**File and selection context.** **UR: Add Current File to Chat** and
+**UR: Add Selection to Chat** attach the active file or selection as explicit
+context. Nothing is sent to UR until one of these actions is taken or a
+message is sent — the extension never silently uploads file content in the
+background.
+
+**Editor actions.** **UR: Explain Selection**, **UR: Fix Selection**, and
+**UR: Generate Tests for Selection** (also on the editor right-click menu)
+open the same chat panel with a structured prompt built from the current
+selection. There is no separate backend path for these — they reuse the chat
+pathway above.
+
+### Actions panel
+
+The **Actions** view lists diff bundles from `.ur/ide/diffs/` and background
+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.
+
+### Agent status card
+
+**UR: Agent Status** opens a panel assembled from `ur ide status --json` and
+`ur provider status --json`: UR version, workspace root, provider, model,
+provider kind (UR-native, subscription CLI, or subscription placeholder),
+native tool-call support, native streaming support, multimodal support, the
+active provider's safety-boundary description, sandbox mode, verifier mode,
+ACP status, plugin count, and warnings, with a refresh button. Any field the
+CLI does not report renders as the literal word **unknown** — never a guess.
+
+### Search actions
+
+**UR: Search Actions** is a single searchable palette covering every stable
+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.
+
+### Agent options panel
+
+**UR: Agent Options** shows recommendations for privacy, speed, multimodal
+support, tool calling, native streaming, subscription CLI access, local/
+offline use, complex refactors, and docs/review work. **This panel is built
+from local, curated data and the UR CLI's own provider registry
+(`ur provider list --json`) only — it is not live market research and does
+not rank model quality.** Every provider is labeled by kind (UR-native,
+subscription CLI, local, or API), and a capability renders as **unknown**
+rather than a guess whenever the CLI does not expose it — for example,
+multimodal support for local/self-hosted models, which depends on whichever
+model happens to be loaded rather than being a fixed provider fact.
+
+### Review Current Diff and Run Verifier
+
+**UR: Review Current Diff** reads the current `git diff` directly through a
+safe subprocess call (no shell interpolation), asks for confirmation before
+sending a large diff, then opens chat with a structured review prompt — the
+diff is never sent without that explicit action.
+
+**UR: Run Verifier** opens chat and asks UR to run its real verification
+subagent (the same mechanism behind the `/verify` prompt command) and report
+a verdict. There is no standalone `ur verify` CLI command today, so this
+always goes through chat rather than a direct CLI call; if the underlying
+`ur` process fails, the panel shows the failure clearly and never reports a
+success it did not observe.
+
+## Known limitations
+
+- **JetBrains is not implemented.** No JetBrains plugin ships from this
+  repository; see "Supported targets" above.
+- **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
+  `/ide` connect flow for live diagnostics and native diff tabs from a
+  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
+  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
 
@@ -75,3 +218,6 @@ Install it with `ur ide install` (offers the bundled VSIX) or from the packaged
   `agent_servers.UR` block from `ur ide config zed`, then reload Zed.
 - **Apply fails in VS Code:** the patch may not match the current tree; re-capture
   with `ur ide diff capture`.
+- **Chat panel shows an error banner:** the underlying `ur` process failed or
+  exited non-zero; check that the UR CLI is on your `PATH` and that a
+  provider/model is configured (`ur provider status`).

package/documentation/index.html

@@ -44,7 +44,7 @@
     <main id="content" class="content">
       <header class="topbar">
         <div>
-          <p class="eyebrow">Version 1.36.1</p>
+          <p class="eyebrow">Version 1.37.0</p>
           <h1>UR-AGENT Documentation</h1>
           <p class="lead">A practical, tutorial-style reference for installing, configuring, automating, extending, and operating UR-AGENT.</p>
         </div>
@@ -159,7 +159,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.36.1 available</code></pre>
+            <pre><code>Ollama | llama3 | ask | main | update 1.37.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 non-interactive mode.</p>
           </article>
         </div>

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

@@ -1,12 +1,39 @@
 # UR Inline Diffs for VS Code
 
-Native VS Code surface for UR inline diff bundles.
+The professional UR IDE integration for VS Code, Cursor, and Windsurf: chat,
+inline diff review, an actions panel, an agent status card, a searchable
+command palette, and an agent options panel — all backed by the `ur` CLI
+already on your machine.
 
 UR-AGENT packages this extension from the repository as a local VSIX when the
 CLI installs the public IDE integration. It does not depend on an unpublished
 marketplace extension ID.
 
-## Workflow
+The extension never talks to a model provider or network service directly —
+every AI request goes through your local `ur` CLI, the same way `ur` behaves
+in a terminal. Everything below requires the UR CLI on your `PATH`.
+
+## Chat
+
+**UR: New Chat** / **UR: Open Chat** open a chat panel that streams UR's
+response as it's generated, over the same NDJSON `stream-json` contract the
+CLI uses for scripted runs. Tool calls, tool results, and permission prompts
+(`control_request`/`control_response`) render inline as they arrive; nothing
+is buffered and shown only at the end, and a failed run shows an error
+banner rather than a fabricated success message.
+
+Each chat is a session persisted under `.ur/ide/chat/` in the workspace, so
+sessions survive closing and reopening VS Code and can be resumed (via the
+CLI's own `--resume`) from **UR: Open Chat**.
+
+**UR: Add Current File to Chat** and **UR: Add Selection to Chat** attach
+context explicitly — nothing is sent to UR until you take one of those
+actions or send a message. **UR: Explain Selection**, **UR: Fix Selection**,
+and **UR: Generate Tests for Selection** (also on the editor right-click
+menu) open the same chat panel with a structured prompt built from the
+current selection; they are not a separate code path from chat.
+
+## Inline diffs and actions panel
 
 Create a bundle from the UR CLI:
 
@@ -14,14 +41,49 @@ Create a bundle from the UR CLI:
 ur ide diff capture --title "Parser fix"
 ```
 
-Open VS Code in the same workspace. The UR activity-bar view lists bundles from
-`.ur/ide/diffs/manifest.json`.
+The **Inline Diffs** view lists bundles from `.ur/ide/diffs/manifest.json`.
+A second view, **Actions**, shows the same diff bundles alongside background
+tasks (`ur bg list`) in one place. Supported actions on a diff bundle:
+
+- refresh the bundle list;
+- open a patch preview with metadata and comments;
+- **Apply** — asks for confirmation, runs `git apply`, then records the
+  approval through `ur ide diff approve` (never a status value the CLI
+  doesn't recognize);
+- **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.
+
+## Status and options
+
+**UR: Agent Status** shows UR version, workspace root, provider, model,
+provider kind, native tool-call/streaming support, multimodal support,
+sandbox mode, verifier mode, ACP status, plugin count, and warnings, built
+from `ur ide status --json` and `ur provider status --json`. Anything the
+CLI doesn't report shows as **unknown**, not a guess.
+
+**UR: Agent Options** shows recommendations for privacy, speed, multimodal,
+tool calling, native streaming, subscription CLI access, local/offline use,
+complex refactors, and docs/review, built from `ur provider list --json`
+plus a small local, curated table. It is not live market research and does
+not rank model quality; it labels each provider's kind (UR-native,
+subscription CLI, local, or API) and uses **unknown** wherever a capability
+isn't known rather than guessing.
+
+## Search
+
+**UR: Search Actions** is one searchable palette for every stable action the
+extension exposes — chat, selection actions, diff review, the verifier, and
+the status/options panels — instead of hunting through the command palette.
 
-Supported actions:
+## Review and verify
 
-- refresh the bundle list
-- open a patch preview with metadata and comments
-- add a comment that writes back to the UR metadata and manifest
+**UR: Review Current Diff** reads your current `git diff`, confirms before
+sending anything large, and opens chat with a structured review prompt.
 
-The extension is local-only. It reads and writes files under the current
-workspace and does not call any model provider or network service.
+**UR: Run Verifier** opens chat and asks UR to run its verification subagent
+and report a verdict; there is no standalone verifier CLI command today, so
+this always goes through chat, and a failed run is always shown as a
+failure, never a false success.