test(relay): keep local E2E traffic off production upstream

* fix(server): resolve ACP providers installed after the daemon started

Windows hands a new process the PATH its parent had when it started. The
daemon's supervisor therefore keeps the PATH it inherited at launch, and any
CLI installed afterwards stays invisible to it. A provider installed after the
daemon started reported "not installed" forever, even though the binary was
on PATH in a fresh shell.

Refresh the process PATH from the Windows user/machine registry environment
when the daemon worker starts. Existing entries keep their order and take
precedence; registry entries are appended. This runs once at startup so
PATH-isolated availability checks and explicit env overrides stay
authoritative.

Spawn the absolute path the launcher resolver verified rather than the bare
command. The resolver already finds installs outside the daemon's inherited
PATH (Winget packages, directories added after startup); the resolved path
was previously discarded.

An ACP agent that exits during the handshake never rejects the SDK's
initialize request, so the provider refresh waited out its full 120s deadline
and reported "Timed out refreshing <provider> after 120000ms; pending:
initialize" instead of the child's stderr. Race a child-exit rejection
against initialize so the real failure surfaces.

Also repair persisted MiniMax Code commands. The first catalog entry ran
`npx -y @minimax-ai/code@<version> acp`; npx derives the executable name from
the package name (`code`), but the package publishes `mcode`, so npm exited
before the ACP handshake. The catalog was fixed separately, but commands
already persisted by an older client were never migrated.

* fix(acp): report startup exits across probes and sessions

Extend the shared process failure handler so initialize rejects with stderr after the child exits, including session creation. Keep this fix scoped to startup error reporting; remove the separate PATH and persisted-command changes.

Co-authored-by: peanut_hzm <peanut_hzm@163.com>

* fix(acp): validate provider options before starting probes

Reject malformed options before creating a child or its process-failure promise, so cleanup cannot cause an unhandled rejection in the daemon.

---------

Co-authored-by: peanut_hzm <peanut_hzm@163.com>
Co-authored-by: paseo-bot[bot] <266920839+paseo-bot[bot]@users.noreply.github.com>

.gitattributes

@@ -0,0 +1,3 @@
+vendor/react-native-gpui/** linguist-vendored
+packages/app/gpui/package-lock.json linguist-generated
+packages/app/gpui/desktop/Cargo.lock linguist-generated

.gitignore

@@ -98,3 +98,9 @@ app.json
 
 # Project-local Serena configuration and memories.
 .serena/
+
+# Vendored experimental React Native desktop runtime.
+!vendor/
+!vendor/react-native-gpui/
+!vendor/react-native-gpui/**
+!packages/app/gpui/app.json

.oxfmtrc.json

@@ -11,5 +11,5 @@
   "arrowParens": "always",
   "bracketSameLine": false,
   "bracketSpacing": true,
-  "ignorePatterns": ["*.lock", "**/*.gen.ts", "**/*.gen.tsx"]
+  "ignorePatterns": ["*.lock", "**/*.gen.ts", "**/*.gen.tsx", "vendor/**"]
 }

.oxlintrc.json

@@ -3,7 +3,7 @@
   "options": {
     "typeAware": false
   },
-  "ignorePatterns": [".dev/**"],
+  "ignorePatterns": [".dev/**", "vendor/**"],
   "plugins": ["react", "react-perf", "unicorn", "typescript", "oxc", "import", "promise"],
   "jsPlugins": ["./scripts/oxlint/paseo-plugin.mjs"],
   "categories": {

docs/custom-providers.md

@@ -65,6 +65,7 @@ per-agent examples and provider-specific keys.
 ## Table of Contents
 
 - [Extending a built-in provider](#extending-a-built-in-provider)
+- [OpenCode with an existing v2 server](#opencode-with-an-existing-v2-server)
 - [Z.AI (Zhipu) coding plan](#zai-zhipu-coding-plan)
 - [Alibaba Cloud (Qwen) coding plan](#alibaba-cloud-qwen-coding-plan)
 - [Codex with a custom OpenAI-compatible endpoint](#codex-with-a-custom-openai-compatible-endpoint)
@@ -107,6 +108,35 @@ See [Codex with a custom OpenAI-compatible endpoint](#codex-with-a-custom-openai
 
 ---
 
+## OpenCode with an existing v2 server
+
+Paseo first uses an explicitly configured server, then a healthy locally registered OpenCode v2 service, then starts its own helper. It never stops a reused service. To select a server explicitly, set its URL in the provider environment:
+
+```json
+{
+  "agents": {
+    "providers": {
+      "opencode": {
+        "env": {
+          "PASEO_OPENCODE_SERVER_URL": "http://127.0.0.1:4096",
+          "PASEO_OPENCODE_SERVER_PASSWORD": "<server password>"
+        }
+      }
+    }
+  }
+}
+```
+
+`PASEO_OPENCODE_SERVER_URL` must be an absolute `http` or `https` URL. Omit `PASEO_OPENCODE_SERVER_PASSWORD` when the server has no authentication; when set, Paseo authenticates with HTTP Basic auth as `opencode`.
+
+A configured URL takes precedence even when unreachable; Paseo reports the connection error. The local service registration supplies its own authentication. For a discovered local service, Paseo installs its bridge package in OpenCode's watched global plugin directory without changing the existing configuration. Refresh reads the existing service's catalogs without starting another server.
+
+An explicitly configured server needs the bridge installed separately. Connect once and start a session: the setup error gives the local package directory. Copy that directory to the server's OpenCode global `plugins` directory, then retry. For a server on another machine, set `PASEO_OPENCODE_BRIDGE_PORT` in the Paseo OpenCode provider environment before starting Paseo, and set `PASEO_OPENCODE_BRIDGE_URL` to the URL the OpenCode server can use to reach that port. For example, an SSH reverse tunnel can expose the Paseo loopback port on the OpenCode host. The bridge token is exchanged through the OpenCode connection and is not written into the plugin package.
+
+OpenCode's custom MCP registrations are shared by all sessions in a location. Paseo rejects custom MCP servers and per-agent process environment overrides on a reused server rather than applying them to other sessions or ignoring them. Session identity is applied to each session's shell environment. A Paseo-owned helper supports custom process and MCP settings; it is selected when there is no explicit URL or healthy registered service.
+
+---
+
 ## Z.AI (Zhipu) coding plan
 
 [Z.AI](https://z.ai) is a Chinese AI company (Zhipu AI) that offers an Anthropic-compatible API endpoint. Their GLM Coding Plan provides flat-rate access to GLM models through Claude Code's Anthropic API protocol. These are **not** Anthropic Claude models — they are Zhipu's own GLM models exposed through an Anthropic-compatible API.

docs/development.md

@@ -29,6 +29,13 @@ the titlebar row. Production builds leave the variable unset and show no label.
 
 `npm run dev` is only a shorthand for `npm run dev:server`. Keep `127.0.0.1:6767` for the packaged app and production-style `~/.paseo` state.
 
+## Experimental GPUI client
+
+The opt-in [GPUI target](../packages/app/gpui/README.md) runs the existing React
+Native app on Linux. Its contributor guide covers setup, the renderer comparison,
+unsupported features, native checks, and experiments to pick up. It connects to
+an already-running daemon and does not replace the Electron dev command.
+
 ## Nix desktop package
 
 The flake exposes `packages.<system>.desktop` on Linux and macOS:

docs/providers.md

@@ -89,7 +89,7 @@ OMP supports native Paseo host tools. The adapter registers the full caller-scop
 
 Pi RPC extension UI dialog requests (`select`, `input`, `editor`, `confirm`) are bridged into Paseo question permissions and answered with `extension_ui_response`. Pi extensions such as `ask_user` may chain dialogs: for example, a `select` can be followed by an optional-comment `input`. When an `ask_user` tool call declares `allowComment: true`, Paseo presents the selection and optional comment as one question permission, answers Pi's initial `select` immediately, then auto-answers the follow-up optional `input` with the comment the user already supplied (or an empty string). Preserve placeholders and optional/skip semantics for standalone optional inputs so the app can still distinguish "skip this optional input" from "cancel the whole dialog." Fire-and-forget extension UI requests such as notifications are intentionally ignored by the provider adapter unless Paseo grows first-class UI for them.
 
-OpenCode adapters target v1.14.46 and v2.0.10. V2 rejects binaries older than the tested 2.0.10 SDK at runtime selection. Runtime selection uses the configured command and environment. A recognized version is cached until provider configuration reload; a failed, timed-out, or unrecognized probe retains the v1 path and retries detection on the next operation. Load v2 code and materialize its plugin only after positive v2 selection; v1 sessions remain undecorated. Keep upstream SDK types inside the version-specific adapter. OpenCode owns storage migration; a missing native session must fail resume rather than create a replacement. V2 has no native archive/unarchive operation: archiving affects Paseo only. V1 retains native archiving.
+OpenCode adapters target v1.14.46 and v2.0.10. V2 rejects versions older than 2.0.10. Paseo selects an explicit server, then a healthy local registered service, then its own helper. It never stops a reused service. A local service loads the Paseo bridge from its watched plugin directory; sessions bind their own bridge credentials through OpenCode RPC. See [OpenCode with an existing v2 server](custom-providers.md#opencode-with-an-existing-v2-server) for setup and isolation limits. Load v2 code and materialize its plugin only after positive v2 selection; v1 sessions remain undecorated. Keep upstream SDK types inside the version-specific adapter. OpenCode owns storage migration; a missing native session must fail resume rather than create a replacement. V2 has no native archive/unarchive operation: archiving affects Paseo only. V1 retains native archiving.
 
 Use OpenCode v2 execution events to trigger turn completion, with active-state and durable-log reconciliation after admission, reconnect, and while a turn remains active. Do not use `session.wait`: a healthy turn exceeding Node's HTTP headers deadline produces a transport error while OpenCode keeps working. The live event feed has no replay, and shutdown interruption preserves the previous idle outcome, so the session snapshot alone cannot recover missed execution events. Quiet streams are healthy: v2 heartbeats are SSE comments, not application events.
 

package.json

@@ -122,7 +122,11 @@
     "release:promote": "npm run release:check && npm run version:all:promote && npm run release:publish && npm run release:push",
     "release:patch": "npm run release:check && npm run version:all:patch && npm run release:publish && npm run release:push",
     "release:minor": "npm run release:check && npm run version:all:minor && npm run release:publish && npm run release:push",
-    "release:major": "npm run release:check && npm run version:all:major && npm run release:publish && npm run release:push"
+    "release:major": "npm run release:check && npm run version:all:major && npm run release:publish && npm run release:push",
+    "gpui:install": "node scripts/gpui.mjs install",
+    "gpui:bundle": "node scripts/gpui.mjs bundle",
+    "build:gpui": "node scripts/gpui.mjs build",
+    "dev:gpui": "node scripts/gpui.mjs run"
   },
   "devDependencies": {
     "@types/ws": "^8.5.14",

packages/app/e2e/browser/composer-autocomplete.spec.ts

@@ -1,5 +1,9 @@
 import { expect, test, type Page } from "../support/fixtures";
-import { composerLocator, expectComposerVisible } from "../support/helpers/composer";
+import {
+  attachFileFromMenu,
+  composerLocator,
+  expectComposerVisible,
+} from "../support/helpers/composer";
 import {
   openAgentRoute,
   seedMockAgentWorkspace,
@@ -365,6 +369,56 @@ function expectPopoverDoesNotDisappearAfterFirstVisible(frames: PopoverFrame[]):
 }
 
 test.describe("Composer autocomplete", () => {
+  test("inserts suggested commands from assistant messages without sending", async ({ page }) => {
+    const requests = recordCommandRequestsByAgentId(page);
+    const session = await seedMockAgentWorkspace({
+      repoPrefix: "suggested-command-",
+      title: "Suggested commands",
+      initialPrompt: "Suggest `/mock` without running it",
+      featureValues: { mockAssistantResponse: "Try `/mock` or [Run mock](/mock)." },
+    });
+    try {
+      await openAgentRoute(page, session);
+      const message = page.getByTestId("assistant-message").filter({ hasText: "Run mock" });
+      await expect(message).toBeVisible();
+      await expect(page.getByTestId("user-message").getByRole("link")).toHaveCount(0);
+      await expect.poll(() => requests.length).toBe(1);
+      await attachFileFromMenu(page, {
+        name: "note.txt",
+        mimeType: "text/plain",
+        buffer: Buffer.from("attachment"),
+      });
+      await expect(page.getByTestId("composer-file-attachment-pill")).toContainText("note.txt");
+      await message.getByRole("link", { name: "/mock", exact: true }).click();
+      await expect(composerLocator(page)).toHaveValue("/mock ");
+      await expect(
+        page.getByTestId("composer-autocomplete-popover").filter({ visible: true }),
+      ).toHaveCount(0);
+      await expect(composerLocator(page)).toBeFocused();
+      await message.getByRole("link", { name: "Run mock" }).click();
+      await expect(composerLocator(page)).toHaveValue("/mock /mock ");
+      await expect(
+        page.getByTestId("composer-autocomplete-popover").filter({ visible: true }),
+      ).toHaveCount(0);
+      await expect(composerLocator(page)).toBeFocused();
+      await expect(page.getByTestId("composer-file-attachment-pill")).toContainText("note.txt");
+      await composerLocator(page).fill("draft");
+      await composerLocator(page).evaluate((element: HTMLTextAreaElement) =>
+        element.setSelectionRange(0, 0),
+      );
+      await message.getByRole("link", { name: "/mock", exact: true }).click();
+      await composerLocator(page).pressSequentially("argument");
+      await expect(composerLocator(page)).toHaveValue("draft /mock argument");
+      await composerLocator(page).fill("/");
+      await expect(
+        page.getByTestId("composer-autocomplete-popover").filter({ visible: true }),
+      ).toContainText("/mock");
+      expect(requests).toHaveLength(1);
+    } finally {
+      await session.cleanup();
+    }
+  });
+
   test("keeps New workspace off the running-agent command list before a project is chosen", async ({
     page,
   }) => {

packages/app/gpui/.gitignore

@@ -0,0 +1,3 @@
+node_modules/
+desktop/build/
+desktop/autolink/

packages/app/gpui/.npmrc

@@ -0,0 +1,3 @@
+workspaces=false
+legacy-peer-deps=true
+install-links=true

packages/app/gpui/README.md

@@ -0,0 +1,202 @@
+# Experimental GPUI client
+
+Run Paseo's existing React Native app in a native GPUI window on Linux. This is
+a community starting point: the real workspace UI runs, but terminal/diff
+renderers and several native services still need porting. The normal desktop
+build remains Electron. No daemon changes or release installers are included.
+
+## Run it
+
+Start from the repository's [development setup](../../../docs/development.md).
+A fresh checkout needs the root dependencies and workspace build outputs:
+
+```sh
+npm ci
+npm run build:server
+npm run gpui:install
+EXPO_PUBLIC_LOCAL_DAEMON=localhost:6768 npm run dev:gpui
+```
+
+Use an already-running compatible daemon and replace `localhost:6768` with its
+endpoint. These GPUI commands never start or restart a daemon. The address is
+inlined at bundle time. The app's normal connection/authentication rules apply.
+
+You also need Rust stable through rustup, CMake, Ninja, Clang, Linux X11/Wayland
+development libraries, and Vulkan. The tested Linux x86_64 host already had
+most build tools; it additionally needed `libxkbcommon-x11-dev`. A clean-machine
+prerequisite check is still needed. The first native build downloads dependencies
+and builds Rust/C++; allow several minutes and several GB of disk.
+
+`dev:gpui` bundles the app, autolinks native modules, builds, and opens the window.
+Restart after editing. It uses an offline production JS bundle; Fast Refresh is
+not wired into this launcher. `build:gpui` builds without opening a window.
+`gpui:bundle -- --dev false` only writes the JS bundle, source map, and assets to
+`.artifacts/gpui/`. Bundle validation checks that the real routes are present and
+that no `react-native-webview` modules were included.
+
+## Approach and renderer choice
+
+```text
+Existing Paseo RootApp + Expo Router + state/client/plugin code
+                         |
+                  React in Hermes
+                         |
+               React Native Fabric
+                         |
+              Rust GPUI native renderer
+                         |
+                  Linux GPU window
+
+Existing Paseo client <-- WebSocket --> separately running Node daemon
+```
+
+The separate npm project is deliberate: the selected runtime uses RN 0.87.1,
+while Paseo's mobile app uses RN 0.86.3. Metro redirects native dependencies to
+that installation and resolves the rest from the app. This avoids changing the
+mobile dependency baseline just to try another renderer. It also creates a
+version-maintenance cost that needs testing before this becomes a supported target.
+
+The choice was to preserve the existing app's RN component and library contracts:
+
+| Candidate                                                                                                                           | Integration model                                                                                                | Consequence for this experiment                                                                                                                                                                                                  |
+| ----------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [Streetwriters react-native-gpui](https://github.com/streetwriters/react-native-gpui/tree/de11aa265e6fb36c80e8a30315bce6d34a9be7d6) | React Native Fabric, Hermes, and GPUI, with ports of screens, gestures, Reanimated/worklets, safe areas, and SVG | Chosen because it lets the existing RN app reach a real Linux window with targeted adapters. These ports are still experimental.                                                                                                 |
+| [natew/react-native-gpui](https://github.com/natew/react-native-gpui/tree/b2254543357f02fdd983d0d8a584d1d1bd93f5da)                 | Custom React reconciler with an RN-like component surface; its README targets macOS arm64/Metal                  | Useful implementation reference. Running this Linux app would also require platform work and compatibility with the RN libraries it imports.                                                                                     |
+| [GPUIX](https://github.com/remorses/gpuix)                                                                                          | Custom React/Solid renderer, its own JSX primitives, and Node-API native bindings; supports Bun/Node execution   | Also native GPUI, with interesting packaging and specialized surfaces. Adopting it would require replacing or adapting Paseo's RN component/library contracts. It remains an alternative worth testing, not a rejected renderer. |
+| Existing Electron target                                                                                                            | RN Web inside Chromium, with the desktop host bridge                                                             | Preserves the working desktop feature set, but does not answer the experiment's question of running the app through a native renderer.                                                                                           |
+
+This is an integration choice, not a performance comparison. There are no
+controlled CPU, memory, startup, or frame-time results against these alternatives.
+
+## What belongs in the change
+
+| Area                                                                   | Why it is here                                                                                                                                                                                                              |
+| ---------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `vendor/react-native-gpui/`                                            | Editable, pinned runtime source. This accounts for roughly 130,000 lines of the diff. GitHub marks it as vendored; inspect [UPSTREAM](../../../vendor/react-native-gpui/UPSTREAM) for provenance and the two local patches. |
+| npm and Cargo lockfiles                                                | Reproduce the experiment's dependencies. Roughly 15,000 generated lines, collapsed on GitHub.                                                                                                                               |
+| `desktop/`, `index.js`, `routes.js`, Metro/Babel config, root launcher | Register the full app, select the native runtime, compile native services, and bundle the actual route graph. The explicit route context prevents an apparently successful build with no app routes.                        |
+| `adapters/`                                                            | Desktop implementations of the app-used APIs, plus explicit unavailable-capability implementations for mobile features. About 700 lines; these are limited ports, not complete replacements for Expo/Unistyles.             |
+| Shared app edits                                                       | One capability gate for alpha-mask shimmer. GPUI shows the logo and labels without that effect. Existing web/iOS/Android paths keep their behavior.                                                                         |
+| Native tests and this guide                                            | Make the working slice reproducible and give contributors bounded follow-up work.                                                                                                                                           |
+
+Upstream examples, its tester/testing package, website, unused fonts/vector-icon
+ports, starter navigation dependencies, sample icon, and unused nested Cargo config
+are omitted. Build outputs, native binaries, downloaded SDKs, logs, screenshots,
+and the exploratory size-measurement copy stay out of Git.
+
+The retained runtime still includes its build machinery, platform backends,
+headers, and tests. Arbitrarily deleting those to reduce line count makes an
+upstream refresh harder. Vendoring can later be replaced by a pinned dependency
+once the local patches are upstreamed and distribution is reproducible.
+
+### Editing the runtime
+
+Edit `vendor/react-native-gpui`, then run `npm run gpui:install` before rebuilding.
+npm copies local packages rather than symlinking them; the install command
+refreshes those copies even when their versions have not changed.
+
+There are two local renderer changes:
+
+- `node_view.rs`: a `pointerEvents="box-none"` view must not install its own hit
+  area. Before the patch, Paseo's empty portal overlay intercepted sidebar clicks.
+- `StatusBar.desktop.js`: desktop windows do not have the mobile OS status bar.
+
+GPUI remains a pinned Cargo git dependency. Upstream tooling downloads Hermes
+and React Native prebuilt libraries. The snapshot is not an offline or fully
+source-built distribution, and release packaging has not been verified.
+
+## Working slice and limits
+
+Verified on Linux x86_64: all 24 app routes in the bundle, connection to the dev
+daemon, the real project/workspace sidebar, opening an existing workspace,
+existing message rendering, and native composer typing/deletion. The native
+regression test restores the draft and does not send a message. Rust tests cover
+SHA-256/random-byte bounds and real SQLite parameter binding/transaction rollback.
+
+The following are not feature-parity claims:
+
+| Area                               | Current state                                                                                                                                                 |
+| ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Styling                            | Adapter evaluates existing Unistyles theme/style factories and breakpoints. No Nitro shadow-tree integration. Full theme/resize behavior needs QA.            |
+| Storage/crypto/localization        | Native filesystem + SQLite + SHA-256 + OS randomness. Intl ships English locale data and IANA time zones. The Rust service contains Linux-specific OS access. |
+| Clipboard/files                    | Text clipboard, native file dialogs, PNG/JPEG picking, and download/export adapters exist. End-to-end dialog/transfer coverage is still missing.              |
+| Voice/camera/push/power inhibition | Unavailable. Requests either report the missing capability or use the app's existing unavailable-capability implementation.                                   |
+| Image conversion/image clipboard   | Unavailable. The picker accepts PNG/JPEG without conversion.                                                                                                  |
+| Mermaid/HTML/document previews     | Mermaid and HTML show source. Document previews report unavailable. No embedded browser backend.                                                              |
+| Terminals                          | The mobile view expects an Expo `PaseoTerminal` component. No GPUI implementation yet.                                                                        |
+| Diffs                              | The mobile surface uses React Native Skia. No GPUI drawing backend yet.                                                                                       |
+| Plugins                            | The existing loader evaluates JS and injects host React/RN. No end-to-end plugin verification on GPUI yet.                                                    |
+| Other platforms                    | The upstream runtime targets macOS/Windows too; this Paseo integration has only been exercised on Linux.                                                      |
+
+The initial stripped development executable was about 68 MiB, with about 10 MiB
+of Hermes/JSI libraries and a 21 MiB JS bundle, approximately 100 MiB uncompressed.
+That measurement excludes the daemon, is not an optimized release installer, and
+does not establish memory usage or a size advantage over another renderer.
+
+## Experiments to pick up
+
+Each experiment should preserve the real app and demonstrate a user workflow.
+
+1. **Native terminal.** Implement a GPUI component for the existing
+   [`PaseoTerminalView`](../modules/paseo-terminal/index.tsx) frame contract.
+   Keep the JS headless xterm emulator, transport, and frame generation initially.
+   Verify resize/replay, keyboard/IME/paste, scrollback/selection, and the existing
+   Unicode corpus. [Terminal rendering](../../../docs/terminal-rendering.md)
+   explains why shaping must preserve xterm's cell columns.
+2. **Diff surface.** Keep `src/git/diff-document`'s model and review actions;
+   add GPUI text measurement and painting instead of the Skia surface. Test
+   unified/split views, wrapping, scrolling, selection, and inline reviews on
+   large real diffs. The [C++ layout experiment](../modules/paseo-diff-prototype/README.md)
+   is a separate candidate for shared geometry; it is not a finished renderer.
+3. **Plugins.** Load a small plugin into an isolated daemon, open its real screen
+   or workspace panel, call a plugin RPC, and reload it. Verify subscriptions and
+   cleanup. Track unsupported services explicitly instead of adding fake APIs.
+4. **Native services and styling.** Exercise dialogs, downloads, clipboard,
+   persistence/restart, theme switching, resizing, and focus. Replace the narrow
+   adapters with complete implementations only where the app needs them.
+5. **Portability and packaging.** Build on clean Linux, then macOS/Windows. Replace
+   Linux-only randomness/timezone access, check font/shaping and IME behavior, and
+   verify relocatable libraries/assets. Measure a release build and a controlled
+   workflow before claiming a performance or size improvement.
+6. **Bundled daemon, independently.** First run the unchanged daemon under Bun
+   in isolation. Verify PTY/native dependencies, terminal-worker subprocesses,
+   provider launches, and dynamic plugins. Then compare standalone/AOT packaging
+   and size. This branch neither ports the daemon nor embeds it in the UI process.
+
+A Rust/GPUI terminal or diff painter can share desktop implementation across the
+upstream renderer's supported OSes. Reusing it on mobile still requires mobile
+bindings and graphics integration; choosing Rust or C++ alone does not provide that.
+
+## Verification
+
+Run the normal checks from the root. GPUI adapters are excluded from the mobile
+TypeScript project; its typecheck alone does not validate this target.
+
+```sh
+npm run typecheck
+npm run lint
+npm run format:check
+```
+
+For the native UI regression, use a daemon with an existing workspace and build
+with the driver. Run the native app on an isolated display when testing on a
+machine in use:
+
+```sh
+EXPO_PUBLIC_LOCAL_DAEMON=localhost:6768 npm run build:gpui -- --features test-driver,visual-capture
+RN_GPUI_TEST_DRIVER=1 RN_GPUI_TEST_DRIVER_TOKEN=local-test \
+RN_GPUI_DEV_MODE=0 RN_GPUI_BUNDLE="$PWD/.artifacts/gpui/paseo.bundle" \
+RN_GPUI_ASSETS_DIR="$PWD/.artifacts/gpui/assets/assets" \
+xvfb-run -a -s '-screen 0 2560x1600x24' \
+packages/app/gpui/desktop/target/debug/react-native-gpui-paseo-gpui
+```
+
+Use the printed `RN_GPUI_TEST_DRIVER_PORT` in another shell:
+
+```sh
+PASEO_GPUI_TEST_URL=ws://127.0.0.1:PORT PASEO_GPUI_TEST_TOKEN=local-test \
+npx vitest run packages/app/gpui/native.test.ts --bail=1
+```
+
+Without a driver URL the test is skipped. Put diagnostic logs/captures in
+`.artifacts/gpui/`; do not commit them or publish private workspace contents as QA.

packages/app/gpui/adapters/async-storage.js

@@ -0,0 +1,73 @@
+import { promises as fs, paths } from "@react-native-gpui/fs";
+import Desktop from "../desktop/src/NativePaseoDesktop";
+
+let writes = Promise.resolve();
+const directory = () => `${paths.appData}/paseo-gpui/storage`;
+const filename = (key) => `${directory()}/${Desktop.sha256(key)}.json`;
+async function read(key) {
+  try {
+    return JSON.parse(await fs.readFile(filename(key), "utf8")).value;
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+function mutate(operation) {
+  const result = writes.then(operation);
+  writes = result.catch(() => {});
+  return result;
+}
+async function write(key, value) {
+  await fs.mkdir(directory(), { recursive: true });
+  const target = filename(key);
+  await fs.writeFile(`${target}.tmp`, JSON.stringify({ key, value }), "utf8");
+  await fs.rename(`${target}.tmp`, target);
+}
+async function keys() {
+  let entries;
+  try {
+    entries = await fs.readdir(directory());
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  return Promise.all(
+    entries
+      .filter((name) => name.endsWith(".json"))
+      .map(async (name) => JSON.parse(await fs.readFile(`${directory()}/${name}`, "utf8")).key),
+  );
+}
+const storage = {
+  async getItem(key) {
+    await writes;
+    return read(key);
+  },
+  setItem(key, value) {
+    return mutate(() => write(key, value));
+  },
+  removeItem(key) {
+    return mutate(() => fs.rm(filename(key), { force: true }));
+  },
+  async getAllKeys() {
+    await writes;
+    return keys();
+  },
+  async multiGet(items) {
+    await writes;
+    return Promise.all(items.map(async (key) => [key, await read(key)]));
+  },
+  multiSet(items) {
+    return mutate(async () => {
+      for (const [key, value] of items) await write(key, value);
+    });
+  },
+  multiRemove(items) {
+    return mutate(async () => {
+      for (const key of items) await fs.rm(filename(key), { force: true });
+    });
+  },
+  clear() {
+    return mutate(() => fs.rm(directory(), { recursive: true, force: true }));
+  },
+};
+export default storage;

packages/app/gpui/adapters/audio.js

@@ -0,0 +1,21 @@
+// Preserve the voice model's lifecycle without loading mobile-only Expo audio
+// during app startup. Requests fail explicitly until a Linux audio backend exists.
+export function createAudioEngine() {
+  const unavailable = async () => {
+    throw new Error("Voice capture and playback are not available in the GPUI build yet.");
+  };
+  return {
+    initialize: unavailable,
+    startCapture: unavailable,
+    play: unavailable,
+    async destroy() {},
+    async stopCapture() {},
+    stop() {},
+    clearQueue() {},
+    isPlaying: () => false,
+    isMuted: () => false,
+    toggleMute() {
+      throw new Error("Voice capture is not available in the GPUI build yet.");
+    },
+  };
+}

packages/app/gpui/adapters/clipboard.js

@@ -0,0 +1,16 @@
+import { TurboModuleRegistry } from "react-native";
+const clipboard = TurboModuleRegistry.getEnforcing("Clipboard");
+export const getStringAsync = () => clipboard.getString();
+export async function setStringAsync(value) {
+  clipboard.setString(value);
+  return true;
+}
+export async function hasStringAsync() {
+  return (await getStringAsync()).length > 0;
+}
+export async function getImageAsync() {
+  throw new Error("Image clipboard is not implemented for GPUI yet");
+}
+export async function setImageAsync() {
+  throw new Error("Image clipboard is not implemented for GPUI yet");
+}

packages/app/gpui/adapters/crypto.js

@@ -0,0 +1,24 @@
+import Desktop from "../desktop/src/NativePaseoDesktop";
+export function getRandomValues(array) {
+  if (
+    !ArrayBuffer.isView(array) ||
+    array instanceof DataView ||
+    array instanceof Float32Array ||
+    array instanceof Float64Array
+  ) {
+    throw new TypeError("getRandomValues requires an integer typed array");
+  }
+  if (array.byteLength > 65536) throw new RangeError("Random request exceeds 65536 bytes");
+  new Uint8Array(array.buffer, array.byteOffset, array.byteLength).set(
+    Desktop.randomBytes(array.byteLength),
+  );
+  return array;
+}
+export function randomUUID() {
+  return globalThis.crypto.randomUUID();
+}
+export const CryptoDigestAlgorithm = { SHA256: "SHA-256" };
+export async function digestStringAsync(algorithm, text) {
+  if (algorithm !== "SHA-256") throw new Error(`Unsupported digest algorithm: ${algorithm}`);
+  return Desktop.sha256(text);
+}

packages/app/gpui/adapters/document-picker.js

@@ -0,0 +1,14 @@
+import { dialog, promises } from "@react-native-gpui/fs";
+export async function getDocumentAsync(options = {}) {
+  const paths = await dialog.open({ multiple: options.multiple ?? false });
+  return {
+    canceled: paths.length === 0,
+    assets: await Promise.all(
+      paths.map(async (path) => ({
+        uri: `file://${path}`,
+        name: path.split("/").at(-1),
+        size: (await promises.stat(path)).size,
+      })),
+    ),
+  };
+}

packages/app/gpui/adapters/document-preview.jsx

@@ -0,0 +1,19 @@
+import React from "react";
+import { ScrollView, Text, View } from "react-native";
+import { HighlightedCodeBlock } from "../../src/components/highlighted-code-block";
+
+export function FileHtmlPreview({ html, testID }) {
+  return (
+    <ScrollView testID={testID}>
+      <Text>HTML rendering is not available in GPUI. Showing source.</Text>
+      <HighlightedCodeBlock code={html} language="html" />
+    </ScrollView>
+  );
+}
+export function DocumentFrame({ testID }) {
+  return (
+    <View testID={testID}>
+      <Text>Document preview is not available in the GPUI build yet.</Text>
+    </View>
+  );
+}

packages/app/gpui/adapters/expo-install.js

@@ -0,0 +1,11 @@
+import {
+  EventEmitter,
+  NativeModule,
+  SharedObject,
+  SharedRef,
+} from "expo-modules-core/src/polyfill/CoreModule";
+export function ensureNativeModulesAreInstalled() {
+  if (globalThis.expo) return;
+  globalThis.expo = { EventEmitter, NativeModule, SharedObject, SharedRef, modules: {} };
+}
+ensureNativeModulesAreInstalled();

packages/app/gpui/adapters/expo-linking.js

@@ -0,0 +1,30 @@
+import { Linking } from "react-native";
+import { NativeModule } from "expo-modules-core/src/polyfill/CoreModule";
+
+class DesktopLinking extends NativeModule {
+  initialURL = null;
+  subscription;
+  constructor() {
+    super();
+    Linking.getInitialURL()
+      .then((url) => {
+        this.initialURL = url;
+        if (url) this.emit("onURLReceived", { url });
+        return url;
+      })
+      .catch((error) => console.error("[GPUI linking]", error));
+  }
+  getLinkingURL = () => this.initialURL;
+  clearInitialURL() {
+    this.initialURL = null;
+  }
+  startObserving() {
+    this.subscription = Linking.addEventListener("url", (event) =>
+      this.emit("onURLReceived", event),
+    );
+  }
+  stopObserving() {
+    this.subscription?.remove();
+  }
+}
+export default new DesktopLinking();

packages/app/gpui/adapters/file-system.js

@@ -0,0 +1,129 @@
+import fs, { promises, paths } from "@react-native-gpui/fs";
+import { Buffer } from "buffer";
+const pathOf = (value) => String(value?.uri ?? value).replace(/^file:\/\//, "");
+const join = (parts) =>
+  parts
+    .map(pathOf)
+    .join("/")
+    .replace(/\/{2,}/g, "/");
+export const cacheDirectory = `file://${paths.appCache}/paseo-gpui/`;
+export const documentDirectory = `file://${paths.appData}/paseo-gpui/`;
+export const EncodingType = { Base64: "base64", UTF8: "utf8" };
+export const Paths = { cache: cacheDirectory, document: documentDirectory };
+export async function getInfoAsync(uri) {
+  try {
+    const stat = await promises.stat(pathOf(uri));
+    return { exists: true, isDirectory: stat.isDirectory(), size: stat.size, uri };
+  } catch (error) {
+    if (error.code === "ENOENT") return { exists: false, uri };
+    throw error;
+  }
+}
+export const makeDirectoryAsync = (uri, options = {}) =>
+  promises.mkdir(pathOf(uri), { recursive: options.intermediates });
+export const copyAsync = ({ from, to }) => promises.copyFile(pathOf(from), pathOf(to));
+export const moveAsync = ({ from, to }) => promises.rename(pathOf(from), pathOf(to));
+export const readAsStringAsync = (uri, options = {}) =>
+  promises.readFile(pathOf(uri), options.encoding ?? "utf8");
+export const writeAsStringAsync = (uri, contents, options = {}) =>
+  promises.writeFile(pathOf(uri), contents, options.encoding ?? "utf8");
+export const deleteAsync = (uri, options = {}) =>
+  promises.rm(pathOf(uri), { recursive: true, force: options.idempotent });
+export const readDirectoryAsync = (uri) => promises.readdir(pathOf(uri));
+export class File {
+  constructor(...parts) {
+    this.uri = `file://${join(parts)}`;
+  }
+  get name() {
+    return pathOf(this).split("/").at(-1);
+  }
+  get exists() {
+    return fs.existsSync(pathOf(this));
+  }
+  get size() {
+    return fs.statSync(pathOf(this)).size;
+  }
+  create({ overwrite = false, intermediates = false } = {}) {
+    if (intermediates)
+      fs.mkdirSync(pathOf(this).split("/").slice(0, -1).join("/"), { recursive: true });
+    fs.writeFileSync(pathOf(this), "", { flag: overwrite ? "w" : "wx" });
+  }
+  write(value) {
+    fs.writeFileSync(pathOf(this), value);
+  }
+  delete() {
+    fs.rmSync(pathOf(this));
+  }
+  async bytes() {
+    return promises.readFile(pathOf(this));
+  }
+  async arrayBuffer() {
+    const bytes = await this.bytes();
+    return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+  }
+  async base64() {
+    return Buffer.from(await this.bytes()).toString("base64");
+  }
+  async text() {
+    return promises.readFile(pathOf(this), "utf8");
+  }
+  move(destination) {
+    fs.renameSync(pathOf(this), pathOf(destination));
+    this.uri = destination.uri;
+  }
+  copy(destination) {
+    fs.copyFileSync(pathOf(this), pathOf(destination));
+  }
+  static async downloadFileAsync(url, destination) {
+    const response = await fetch(url);
+    if (!response.ok) throw new Error(`Download failed: ${response.status}`);
+    const file = destination instanceof File ? destination : new File(destination);
+    await promises.writeFile(pathOf(file), new Uint8Array(await response.arrayBuffer()));
+    return file;
+  }
+}
+export class Directory {
+  constructor(...parts) {
+    this.uri = `file://${join(parts)}`;
+  }
+  get exists() {
+    return fs.existsSync(pathOf(this));
+  }
+  create({ intermediates = false } = {}) {
+    fs.mkdirSync(pathOf(this), { recursive: intermediates });
+  }
+  delete() {
+    fs.rmSync(pathOf(this), { recursive: true });
+  }
+  list() {
+    return fs
+      .readdirSync(pathOf(this), { withFileTypes: true })
+      .map((entry) =>
+        entry.isDirectory() ? new Directory(this, entry.name) : new File(this, entry.name),
+      );
+  }
+}
+
+export function createDownloadResumable(url, uri, options = {}, onProgress) {
+  const controller = new AbortController();
+  return {
+    async downloadAsync() {
+      const response = await fetch(url, { headers: options.headers, signal: controller.signal });
+      if (!response.ok) throw new Error(`Download failed: ${response.status}`);
+      const bytes = new Uint8Array(await response.arrayBuffer());
+      const target = pathOf(uri);
+      await promises.mkdir(target.split("/").slice(0, -1).join("/"), { recursive: true });
+      await promises.writeFile(`${target}.part`, bytes);
+      await promises.rename(`${target}.part`, target);
+      onProgress?.({ totalBytesWritten: bytes.length, totalBytesExpectedToWrite: bytes.length });
+      return {
+        uri,
+        status: response.status,
+        headers: Object.fromEntries(response.headers.entries()),
+      };
+    },
+    async cancelAsync() {
+      controller.abort();
+    },
+  };
+}

packages/app/gpui/adapters/image-manipulator.js

@@ -0,0 +1,8 @@
+// The GPUI picker accepts JPEG/PNG directly. Other formats require a future
+// native decoder; never claim conversion succeeded for an unsupported format.
+export const SaveFormat = { PNG: "png", JPEG: "jpeg", WEBP: "webp" };
+export const ImageManipulator = {
+  manipulate() {
+    throw new Error("Image conversion is not available in the GPUI build; select a PNG or JPEG.");
+  },
+};

packages/app/gpui/adapters/image-picker.js

@@ -0,0 +1,28 @@
+import { dialog, promises } from "@react-native-gpui/fs";
+// Desktop access is granted for each selection by the system file dialog.
+export const PermissionStatus = {
+  GRANTED: "granted",
+  DENIED: "denied",
+  UNDETERMINED: "undetermined",
+};
+const permission = { status: "granted", granted: true, canAskAgain: true, expires: "never" };
+export const requestMediaLibraryPermissionsAsync = async () => permission;
+export const useMediaLibraryPermissions = () => [permission, requestMediaLibraryPermissionsAsync];
+export const getPendingResultAsync = async () => null;
+export async function launchImageLibraryAsync(options = {}) {
+  const paths = await dialog.open({
+    multiple: options.allowsMultipleSelection,
+    filters: [{ name: "Images", extensions: ["png", "jpg", "jpeg"] }],
+  });
+  return {
+    canceled: !paths.length,
+    assets: await Promise.all(
+      paths.map(async (path) => ({
+        uri: `file://${path}`,
+        fileName: path.split("/").at(-1),
+        fileSize: (await promises.stat(path)).size,
+        mimeType: /\.png$/i.test(path) ? "image/png" : "image/jpeg",
+      })),
+    ),
+  };
+}

packages/app/gpui/adapters/intl.js

@@ -0,0 +1,16 @@
+/* oxlint-disable import/no-unassigned-import -- These packages install Intl and locale data by side effect. */
+// Hermes' Linux build omits Intl; install real locale algorithms before app code.
+import "@formatjs/intl-getcanonicallocales/polyfill-force.js";
+import "@formatjs/intl-locale/polyfill-force.js";
+import "@formatjs/intl-pluralrules/polyfill-force.js";
+import "@formatjs/intl-pluralrules/locale-data/en.js";
+import "@formatjs/intl-numberformat/polyfill-force.js";
+import "@formatjs/intl-numberformat/locale-data/en.js";
+import "@formatjs/intl-datetimeformat/polyfill-force.js";
+import "@formatjs/intl-datetimeformat/locale-data/en.js";
+import "@formatjs/intl-datetimeformat/add-all-tz.js";
+import "@formatjs/intl-displaynames/polyfill-force.js";
+import "@formatjs/intl-displaynames/locale-data/en.js";
+import "@formatjs/intl-segmenter/polyfill-force.js";
+import Desktop from "../desktop/src/NativePaseoDesktop";
+Intl.DateTimeFormat.__setDefaultTimeZone(Desktop.timezone());

packages/app/gpui/adapters/keep-awake.js

@@ -0,0 +1,6 @@
+// No desktop power-inhibition lease is acquired by this backend yet.
+export const isAvailableAsync = async () => false;
+export async function activateKeepAwakeAsync() {
+  throw new Error("Power inhibition is not available in the GPUI build.");
+}
+export async function deactivateKeepAwake() {}

packages/app/gpui/adapters/keyboard.jsx

@@ -0,0 +1,60 @@
+import { useEffect } from "react";
+import { Keyboard, ScrollView, useAnimatedValue } from "react-native";
+import { useSharedValue } from "react-native-reanimated";
+
+// A GPUI desktop window has no software-keyboard inset. RN still owns focus
+// and physical keyboard events; the mobile layout API observes its events.
+export function KeyboardProvider({ children }) {
+  return children;
+}
+export const KeyboardAwareScrollView = ScrollView;
+export const KeyboardController = {
+  isVisible: () => Keyboard.isVisible(),
+  dismiss: () => Keyboard.dismiss(),
+};
+export const KeyboardEvents = { addListener: (...args) => Keyboard.addListener(...args) };
+export function useReanimatedKeyboardAnimation() {
+  const height = useSharedValue(0);
+  const progress = useSharedValue(0);
+  useEffect(() => {
+    const shown = Keyboard.addListener("keyboardDidShow", (event) => {
+      height.value = -event.endCoordinates.height;
+      progress.value = 1;
+    });
+    const hidden = Keyboard.addListener("keyboardDidHide", () => {
+      height.value = 0;
+      progress.value = 0;
+    });
+    return () => {
+      shown.remove();
+      hidden.remove();
+    };
+  }, [height, progress]);
+  return { height, progress };
+}
+export function useKeyboardAnimation() {
+  const height = useAnimatedValue(0);
+  const progress = useAnimatedValue(0);
+  return { height, progress };
+}
+export function useGenericKeyboardHandler(handlers) {
+  useEffect(() => {
+    const subscriptions = [
+      Keyboard.addListener("keyboardDidShow", (event) => {
+        const value = {
+          height: event.endCoordinates.height,
+          progress: 1,
+          duration: event.duration,
+        };
+        handlers.onStart?.(value);
+        handlers.onEnd?.(value);
+      }),
+      Keyboard.addListener("keyboardDidHide", () => {
+        const value = { height: 0, progress: 0, duration: 0 };
+        handlers.onStart?.(value);
+        handlers.onEnd?.(value);
+      }),
+    ];
+    return () => subscriptions.forEach((subscription) => subscription.remove());
+  }, [handlers]);
+}

packages/app/gpui/adapters/localization.js

@@ -0,0 +1,5 @@
+import Desktop from "../desktop/src/NativePaseoDesktop";
+export function getLocales() {
+  const languageTag = Desktop.locale().split(".")[0].replaceAll("_", "-");
+  return [{ languageTag, languageCode: languageTag.split("-")[0] }];
+}

packages/app/gpui/adapters/mermaid.jsx

@@ -0,0 +1,13 @@
+import React from "react";
+import { Text, View } from "react-native";
+import { HighlightedCodeBlock } from "../../src/components/highlighted-code-block";
+export function MermaidFenceHost(props) {
+  return (
+    <View>
+      <Text style={props.inheritedStyles}>
+        Diagram rendering is not available in the GPUI build yet.
+      </Text>
+      <HighlightedCodeBlock {...props} language="mermaid" />
+    </View>
+  );
+}

packages/app/gpui/adapters/node-crypto.js

@@ -0,0 +1,5 @@
+import { Buffer } from "buffer";
+import Desktop from "../desktop/src/NativePaseoDesktop";
+export function randomBytes(length) {
+  return Buffer.from(Desktop.randomBytes(length));
+}

packages/app/gpui/adapters/paste-input.js

@@ -0,0 +1,3 @@
+// GPUI's native TextInput owns text paste, selection, and IME. The mobile
+// PasteInput module's image-paste extension is not available on this target.
+export { TextInput as default } from "react-native";

packages/app/gpui/adapters/sharing.js

@@ -0,0 +1,11 @@
+import { dialog, promises } from "@react-native-gpui/fs";
+// Linux exports a downloaded file through the native Save dialog.
+export const isAvailableAsync = async () => true;
+export async function shareAsync(uri, options = {}) {
+  const source = uri.replace(/^file:\/\//, "");
+  const destination = await dialog.save({
+    title: options.dialogTitle ?? "Save file",
+    defaultName: source.split("/").at(-1),
+  });
+  if (destination) await promises.copyFile(source, destination);
+}

packages/app/gpui/adapters/sqlite.js

@@ -0,0 +1,37 @@
+import Desktop from "../desktop/src/NativePaseoDesktop";
+let pending = Promise.resolve();
+function enqueue(operation) {
+  const result = pending.then(operation);
+  pending = result.catch(() => {});
+  return result;
+}
+const connection = {
+  async execAsync(sql) {
+    Desktop.sqlite(sql, "batch");
+  },
+  async runAsync(sql, params = []) {
+    Desktop.sqlite(sql, JSON.stringify(params));
+  },
+  async getAllAsync(sql, params = []) {
+    return JSON.parse(Desktop.sqlite(sql, JSON.stringify(params)));
+  },
+};
+export async function openDatabaseAsync(name) {
+  if (name !== "paseo-replica-row-store.db") throw new Error(`Unknown GPUI database: ${name}`);
+  return {
+    execAsync: (...args) => enqueue(() => connection.execAsync(...args)),
+    runAsync: (...args) => enqueue(() => connection.runAsync(...args)),
+    getAllAsync: (...args) => enqueue(() => connection.getAllAsync(...args)),
+    withExclusiveTransactionAsync: (operation) =>
+      enqueue(async () => {
+        await connection.execAsync("BEGIN IMMEDIATE");
+        try {
+          await operation(connection);
+          await connection.execAsync("COMMIT");
+        } catch (error) {
+          await connection.execAsync("ROLLBACK");
+          throw error;
+        }
+      }),
+  };
+}

packages/app/gpui/adapters/unistyles-components.js

@@ -0,0 +1,26 @@
+import * as RN from "react-native";
+import { createUnistylesElement } from "./unistyles";
+export const View = createUnistylesElement(RN.View);
+export const Text = createUnistylesElement(RN.Text);
+export const ScrollView = createUnistylesElement(RN.ScrollView);
+export const TextInput = createUnistylesElement(RN.TextInput);
+export const Pressable = createUnistylesElement(RN.Pressable);
+export const Image = createUnistylesElement(RN.Image);
+export const ImageBackground = createUnistylesElement(RN.ImageBackground);
+export const FlatList = createUnistylesElement(RN.FlatList);
+export const SectionList = createUnistylesElement(RN.SectionList);
+export const TouchableOpacity = createUnistylesElement(RN.TouchableOpacity);
+export const TouchableHighlight = createUnistylesElement(RN.TouchableHighlight);
+export const TouchableWithoutFeedback = createUnistylesElement(RN.TouchableWithoutFeedback);
+export const ActivityIndicator = createUnistylesElement(RN.ActivityIndicator);
+export const KeyboardAvoidingView = createUnistylesElement(RN.KeyboardAvoidingView);
+export const SafeAreaView = createUnistylesElement(RN.SafeAreaView);
+export const Switch = createUnistylesElement(RN.Switch);
+export const StatusBar = RN.StatusBar;
+export const Animated = {
+  ...RN.Animated,
+  View: createUnistylesElement(RN.Animated.View),
+  Text: createUnistylesElement(RN.Animated.Text),
+  ScrollView: createUnistylesElement(RN.Animated.ScrollView),
+  Image: createUnistylesElement(RN.Animated.Image),
+};

packages/app/gpui/adapters/unistyles.js

@@ -0,0 +1,140 @@
+import React, { forwardRef, useSyncExternalStore } from "react";
+import * as Native from "react-native";
+
+// GPUI has Fabric but no Nitro/Unistyles shadow-tree bindings. Keep the app's
+// style factories and theme API; this backend updates subscribed React views.
+const listeners = new Set();
+const resolveStyle = Symbol("paseo.gpui.style");
+let revision = 0;
+let themes = {};
+let themeName = "dark";
+let adaptive = true;
+let breakpoints = {};
+const emit = () => {
+  revision += 1;
+  for (const listener of listeners) listener();
+};
+const subscribe = (listener) => {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+};
+const snapshot = () => revision;
+const theme = () => themes[themeName];
+const runtime = () => ({
+  themeName,
+  colorScheme: Native.Appearance.getColorScheme() ?? "light",
+  screen: Native.Dimensions.get("window"),
+  insets: { top: 0, bottom: 0, left: 0, right: 0, ime: 0 },
+  pixelRatio: Native.PixelRatio.get(),
+  fontScale: Native.PixelRatio.getFontScale(),
+  breakpoint: Object.keys(breakpoints).findLast(
+    (key) => breakpoints[key] <= Native.Dimensions.get("window").width,
+  ),
+});
+Native.Dimensions.addEventListener("change", emit);
+Native.Appearance.addChangeListener(({ colorScheme }) => {
+  if (adaptive && themes[colorScheme]) themeName = colorScheme;
+  emit();
+});
+function responsive(value) {
+  if (Array.isArray(value)) return value.map(responsive);
+  if (!value || typeof value !== "object") return value;
+  if (Object.getPrototypeOf(value) !== Object.prototype) return value;
+  const keys = Object.keys(value);
+  if (keys.length && keys.every((key) => key in breakpoints)) {
+    const width = Native.Dimensions.get("window").width;
+    const key = keys
+      .sort((a, b) => breakpoints[a] - breakpoints[b])
+      .findLast((candidate) => breakpoints[candidate] <= width);
+    return key === undefined ? undefined : responsive(value[key]);
+  }
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, responsive(item)]));
+}
+function materialize(style) {
+  if (Array.isArray(style)) return style.map(materialize);
+  if (style && typeof style === "object" && style[resolveStyle]) return style[resolveStyle]();
+  return style;
+}
+function styledProps(props) {
+  const result = { ...props };
+  for (const key of ["style", "contentContainerStyle"]) {
+    if (typeof props[key] === "function")
+      result[key] = (...args) => materialize(props[key](...args));
+    else if (props[key]) result[key] = materialize(props[key]);
+  }
+  return result;
+}
+export const UnistylesRuntime = {
+  get themeName() {
+    return themeName;
+  },
+  get breakpoint() {
+    return runtime().breakpoint;
+  },
+  get colorScheme() {
+    return runtime().colorScheme;
+  },
+  getTheme: theme,
+  setTheme(name) {
+    if (!themes[name]) throw new Error(`Unknown GPUI theme: ${name}`);
+    themeName = name;
+    emit();
+  },
+  updateTheme(name, update) {
+    themes[name] = update(themes[name]);
+    emit();
+  },
+  setAdaptiveThemes(value) {
+    adaptive = value;
+    if (value && themes[runtime().colorScheme]) themeName = runtime().colorScheme;
+    emit();
+  },
+};
+export const StyleSheet = {
+  ...Native.StyleSheet,
+  configure(config) {
+    themes = config.themes;
+    breakpoints = config.breakpoints;
+    adaptive = config.settings?.adaptiveThemes ?? false;
+    themeName =
+      config.settings?.initialTheme ?? (adaptive ? runtime().colorScheme : Object.keys(themes)[0]);
+    emit();
+  },
+  create(factory) {
+    const evaluate = () => (typeof factory === "function" ? factory(theme(), runtime()) : factory);
+    const initial = evaluate();
+    const sheet = {};
+    for (const key of Object.keys(initial)) {
+      const wrap = (args) => {
+        const resolve = () => {
+          const value = evaluate()[key];
+          return responsive(typeof value === "function" ? value(...args) : value);
+        };
+        return Object.defineProperty({ ...resolve() }, resolveStyle, { value: resolve });
+      };
+      sheet[key] = typeof initial[key] === "function" ? (...args) => wrap(args) : wrap([]);
+    }
+    return sheet;
+  },
+};
+// Existing consumers retain this API; new app code should use style factories.
+export function useUnistyles() {
+  useSyncExternalStore(subscribe, snapshot, snapshot);
+  return { theme: theme(), rt: runtime() };
+}
+export function withUnistyles(Component, mappings) {
+  const Wrapped = forwardRef(function GpuiThemed(props, ref) {
+    useSyncExternalStore(subscribe, snapshot, snapshot);
+    const { uniProps, ...rest } = props;
+    return React.createElement(Component, {
+      ...styledProps({
+        ...mappings?.(theme(), runtime()),
+        ...uniProps?.(theme(), runtime()),
+        ...rest,
+      }),
+      ref,
+    });
+  });
+  return Wrapped;
+}
+export const createUnistylesElement = withUnistyles;

packages/app/gpui/app.json

@@ -0,0 +1 @@
+{ "name": "Paseo", "displayName": "Paseo GPUI" }

packages/app/gpui/babel.config.js

@@ -0,0 +1,7 @@
+module.exports = function (api) {
+  api.cache(true);
+  return {
+    presets: [[require.resolve("babel-preset-expo"), { unstable_transformImportMeta: true }]],
+    plugins: [[require.resolve("react-native-unistyles/plugin"), { root: "../src" }]],
+  };
+};

packages/app/gpui/desktop/.gitignore

@@ -0,0 +1,4 @@
+build/
+.cache/
+autolink/
+target/

packages/app/gpui/desktop/Cargo.toml

@@ -0,0 +1,55 @@
+[package]
+name = "react-native-gpui-paseo-gpui"
+version = "0.1.0"
+edition = "2021"
+
+# Set CARGO_PROFILE_DEV_DEBUG=full to opt into full debug information.
+[profile.dev]
+debug = "line-tables-only"
+split-debuginfo = "packed"
+
+# Dependencies are optimized even in a dev build: GPUI rebuilds and paints the
+# element tree on every frame, and they are only compiled once.
+[profile.dev.package."*"]
+debug = false
+opt-level = 3
+
+# The C++ bridge picks its CMake build type from this crate's opt-level, and a
+# Release build of React Native has no dev server, inspector or Fast Refresh.
+[profile.dev.package.rn-gpui-sys]
+opt-level = 0
+
+[profile.release]
+debug = "line-tables-only"
+# Cargo strips inside the linker, before dsymutil, so package-desktop writes the
+# dSYM and then strips. Full LTO: 2 MB smaller for 1.4x the build time.
+strip = "none"
+split-debuginfo = "packed"
+lto = "fat"
+codegen-units = 1
+
+[build-dependencies]
+rn-gpui-module-build = { path = "../node_modules/@react-native-gpui/core/ReactGpui/rn-gpui-module-build" }
+serde_json = "1"
+
+[features]
+visual-capture = ["react-native-gpui/visual-capture"]
+test-driver = ["react-native-gpui/test-driver"]
+
+[dependencies]
+serde_json = "1"
+sha2 = "0.10"
+rusqlite = { version = "0.38", features = ["bundled"] }
+rn-gpui-module = { path = "../node_modules/@react-native-gpui/core/ReactGpui/rn-gpui-module" }
+rn-gpui-autolink = { path = "autolink" }
+react-native-gpui = { path = "../node_modules/@react-native-gpui/core/ReactGpui/rn-gpui" }
+
+[patch.crates-io]
+# Managed by @react-native-gpui/cli autolink; do not edit between these markers.
+react-native-gpui = { path = "../node_modules/@react-native-gpui/core/ReactGpui/rn-gpui" }
+rn-gpui-sys = { path = "../node_modules/@react-native-gpui/core/ReactGpui/rn-gpui-sys" }
+rn-gpui-module = { path = "../node_modules/@react-native-gpui/core/ReactGpui/rn-gpui-module" }
+rn-gpui-module-build = { path = "../node_modules/@react-native-gpui/core/ReactGpui/rn-gpui-module-build" }
+gpui = { git = "https://github.com/streetwriters/gpui-fast", rev = "8da7d89" }
+gpui_platform = { git = "https://github.com/streetwriters/gpui-fast", rev = "8da7d89" }
+# End managed by autolink.

packages/app/gpui/desktop/build.rs

@@ -0,0 +1,172 @@
+fn main() {
+    // Forwards the engine's Node-API exports out of this executable, which is
+    // what lets a stock `.node` addon resolve them on Windows.
+    //
+    // A DLL records every import as a name *plus the file it comes from*, and a
+    // node-gyp addon records "from `node.exe`" — Windows has no global symbol
+    // scope for it to fall back on. Node's own answer is that the host process
+    // exports the Node-API functions, so that is what this does: the executable
+    // re-exports each of the VM's `napi_*`/`node_api_*` names, forwarded to
+    // `hermesvm.dll`. Addons that use node-gyp's delay-load hook (the default)
+    // then reach this process instead of looking for `node.exe` on disk.
+    //
+    // It is a no-op on macOS and Linux, where an addon's imports resolve against
+    // whatever is already loaded and need no forwarding. Declare it once, before
+    // the module list; it does not depend on anything else in this file.
+    rn_gpui_module_build::forward_node_api_exports();
+
+    // App-local Rust TurboModules: list one entry per `src/Native*.ts` spec,
+    // for example `&["src/NativeGreeting.ts"]`. Their glue is generated into
+    // this crate's OUT_DIR, and main.rs registers the modules.
+    rn_gpui_module_build::generate(&["src/NativePaseoDesktop.ts"]);
+
+    let desktop_root = std::path::PathBuf::from(
+        std::env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR is set"),
+    );
+    // `app.json` names the app; `desktop/desktop.json` carries the identifier
+    // and everything else the packaging step needs. The loader the CLI uses is
+    // JavaScript, so this reads the same file directly and applies the two
+    // defaults it would apply.
+    let project_root = desktop_root
+        .parent()
+        .expect("desktop folder has a React Native project root");
+    let app_json_path = project_root.join("app.json");
+    println!("cargo:rerun-if-changed={}", app_json_path.display());
+    let app_json: serde_json::Value = serde_json::from_slice(
+        &std::fs::read(&app_json_path)
+            .unwrap_or_else(|error| panic!("read {}: {error}", app_json_path.display())),
+    )
+    .unwrap_or_else(|error| panic!("parse {}: {error}", app_json_path.display()));
+    let app_name = app_json["name"]
+        .as_str()
+        .filter(|name| !name.is_empty())
+        .expect("app.json must define a nonempty name");
+    if app_json["desktop"]
+        .as_object()
+        .is_some_and(|desktop| !desktop.is_empty())
+    {
+        panic!("move `app.json` desktop.* into `desktop/desktop.json` (see the README)");
+    }
+
+    let desktop_json_path = project_root.join("desktop/desktop.json");
+    println!("cargo:rerun-if-changed={}", desktop_json_path.display());
+    let desktop_json: serde_json::Value = std::fs::read(&desktop_json_path)
+        .ok()
+        .and_then(|bytes| serde_json::from_slice(&bytes).ok())
+        .unwrap_or(serde_json::Value::Null);
+    let app_id = match desktop_json["identifier"].as_str() {
+        Some(identifier) if !identifier.is_empty() => identifier.to_string(),
+        _ => format!(
+            "com.example.{}",
+            app_name
+                .to_lowercase()
+                .chars()
+                .map(|c| if c.is_ascii_alphanumeric() { c } else { '-' })
+                .collect::<String>()
+        ),
+    };
+    println!("cargo:rustc-env=RN_GPUI_APP_NAME={app_name}");
+    println!("cargo:rustc-env=RN_GPUI_APP_ID={app_id}");
+    // Only a debug build names the bundle it was developed against. A release
+    // binary must find the bundle beside its own executable, because the path
+    // baked in here is where this machine happened to build it — and on the
+    // machine the package is installed on, that path does not exist.
+    println!("cargo:rerun-if-env-changed=PROFILE");
+    if std::env::var("PROFILE").as_deref() == Ok("debug") {
+        println!(
+            "cargo:rustc-env=RN_GPUI_DEFAULT_BUNDLE={}",
+            desktop_root.join("build/index.bundle").display()
+        );
+    }
+
+    println!("cargo:rerun-if-env-changed=DEP_RN_GPUI_RUNTIME_RPATHS");
+    println!("cargo:rerun-if-env-changed=RN_GPUI_PACKAGING");
+    let Ok(paths) = std::env::var("DEP_RN_GPUI_RUNTIME_RPATHS") else {
+        return;
+    };
+    let dirs = paths.split('|').filter(|path| !path.is_empty());
+    if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("windows") {
+        stage_shared_libraries(dirs);
+        return;
+    }
+    // `RN_GPUI_PACKAGING` means this binary is about to be installed somewhere
+    // else, so only the relative rpaths belong in it. Keeping the absolute ones
+    // would let a packaged app load this build tree's libraries in preference to
+    // its own on the machine that built it — which hides exactly the packaging
+    // bugs the packaged run exists to catch.
+    let packaging = std::env::var("RN_GPUI_PACKAGING").is_ok();
+    if !packaging {
+        for path in dirs {
+            println!("cargo:rustc-link-arg=-Wl,-rpath,{path}");
+        }
+    }
+    emit_relocatable_rpaths(app_name);
+}
+
+/// rpaths that survive being installed somewhere else.
+///
+/// The absolute paths above let a development build run from this tree. A
+/// packaged app is copied to another machine, where those paths do not exist,
+/// so a release build also carries paths relative to the executable: the
+/// layout the installers produce.
+fn emit_relocatable_rpaths(app_name: &str) {
+    if std::env::var("PROFILE").as_deref() != Ok("release") {
+        return;
+    }
+    let os = std::env::var("CARGO_CFG_TARGET_OS").unwrap_or_default();
+    let mut emit = |rpath: String| println!("cargo:rustc-link-arg=-Wl,-rpath,{rpath}");
+    match os.as_str() {
+        // An app bundle puts the executable in Contents/MacOS and the shipped
+        // libraries in Contents/Frameworks.
+        "macos" => emit("@executable_path/../Frameworks".into()),
+        // Linux installs the executable at `usr/bin` and ships its libraries
+        // under `usr/lib`:
+        // - the deb puts them in `usr/lib/<app>`;
+        // - an AppImage's libraries are flat in `usr/lib`, because that is the
+        //   directory AppRun puts on the library path and the one linuxdeploy
+        //   resolves dependencies from before the image is assembled.
+        // Both are covered, so one binary works in either layout.
+        "linux" => {
+            emit(format!("$ORIGIN/../lib/{app_name}"));
+            emit("$ORIGIN/../lib".into());
+            emit("$ORIGIN".into());
+        }
+        // Windows has no rpath: the DLLs are copied beside the executable.
+        _ => {}
+    }
+}
+
+/// Windows has no rpath: the loader finds a DLL next to the executable or on
+/// `PATH`, so every directory the runtime reports as holding a shared library
+/// (the Hermes binary directory in particular) is copied into the profile
+/// directory that receives this app's executable. Without this the app builds
+/// and then fails to start with "hermesvm.dll was not found".
+fn stage_shared_libraries<'a>(dirs: impl Iterator<Item = &'a str>) {
+    let out_dir = std::path::PathBuf::from(std::env::var("OUT_DIR").expect("OUT_DIR is set"));
+    // <profile>/build/<package>-<hash>/out -> <profile>
+    let Some(profile_dir) = out_dir.ancestors().nth(3) else {
+        return;
+    };
+    for dir in dirs {
+        let Ok(entries) = std::fs::read_dir(dir) else {
+            continue;
+        };
+        for entry in entries.flatten() {
+            let source = entry.path();
+            let is_shared_library = source
+                .extension()
+                .and_then(|extension| extension.to_str())
+                .is_some_and(|extension| extension.eq_ignore_ascii_case("dll"));
+            if !is_shared_library {
+                continue;
+            }
+            let Some(name) = source.file_name() else {
+                continue;
+            };
+            println!("cargo:rerun-if-changed={}", source.display());
+            std::fs::copy(&source, profile_dir.join(name)).unwrap_or_else(|error| {
+                panic!("copy {} next to the executable: {error}", source.display())
+            });
+        }
+    }
+}

packages/app/gpui/desktop/desktop.json

@@ -0,0 +1 @@
+{ "identifier": "sh.paseo.gpui" }

packages/app/gpui/desktop/metro.config.js

@@ -0,0 +1,83 @@
+const path = require("node:path");
+const { makeMetroConfig } = require("@react-native-gpui/core/metro.config");
+const projectRoot = path.resolve(__dirname, "..");
+process.env.EXPO_ROUTER_APP_ROOT = path.resolve(projectRoot, "../src/app");
+const config = makeMetroConfig({ projectRoot });
+const resolveRequest = config.resolver.resolveRequest;
+config.watchFolders.push(path.resolve(projectRoot, "../../.."));
+config.transformer.unstable_allowRequireContext = true;
+config.resolver.disableHierarchicalLookup = false;
+config.resolver.blockList = /[/\\]gpui[/\\]desktop[/\\](target|build|autolink)[/\\]/;
+const nativePackages = [
+  "react",
+  "react-native-reanimated",
+  "react-native-worklets",
+  "react-native-gesture-handler",
+  "react-native-screens",
+  "react-native-safe-area-context",
+  "react-native-svg",
+];
+
+const adapters = {
+  "expo-keep-awake": "keep-awake.js",
+  "expo-image-picker": "image-picker.js",
+  "expo-image-manipulator": "image-manipulator.js",
+  "expo-sharing": "sharing.js",
+  "expo-document-picker": "document-picker.js",
+  "@mattermost/react-native-paste-input": "paste-input.js",
+  "@react-native-async-storage/async-storage": "async-storage.js",
+  "expo-localization": "localization.js",
+  "expo-clipboard": "clipboard.js",
+  "expo-file-system": "file-system.js",
+  "expo-file-system/legacy": "file-system.js",
+  "react-native-keyboard-controller": "keyboard.jsx",
+  crypto: "node-crypto.js",
+  "node:crypto": "node-crypto.js",
+  "expo-sqlite": "sqlite.js",
+  "expo-crypto": "crypto.js",
+  "react-native-unistyles": "unistyles.js",
+};
+const fileAdapters = {
+  "/audio/audio-engine.native.ts": "audio.js",
+  "/components/markdown/fence/mermaid/host.native.tsx": "mermaid.jsx",
+  "/file-panels/html-preview.tsx": "document-preview.jsx",
+  "/file-panels/document-frame/index.tsx": "document-preview.jsx",
+};
+config.resolver.resolveRequest = (context, name, platform) => {
+  if (adapters[name]) name = path.resolve(projectRoot, "adapters", adapters[name]);
+  if (
+    name.endsWith("/ensureNativeModulesAreInstalled") &&
+    context.originModulePath.includes("expo-modules-core")
+  )
+    name = path.resolve(projectRoot, "adapters/expo-install.js");
+  if (name === "./ExpoLinking" && context.originModulePath.includes("expo-linking"))
+    name = path.resolve(projectRoot, "adapters/expo-linking.js");
+  // Linux has no Expo mobile push-token or camera provider; reuse the app's
+  // existing unavailable-capability implementations.
+  if (name === "expo-notifications")
+    name = path.resolve(projectRoot, "../src/fdroid/expo-notifications.ts");
+  if (name === "expo-camera") name = path.resolve(projectRoot, "../src/fdroid/expo-camera.tsx");
+  if (name === "expo-router/_ctx") name = path.resolve(projectRoot, "routes.js");
+  if (name === "qrcode") name = "qrcode/lib/browser.js";
+  if (name.startsWith("react-native-unistyles/components/native/"))
+    name = path.resolve(projectRoot, "adapters/unistyles-components.js");
+  if (name.startsWith("@/")) name = path.resolve(projectRoot, "../src", name.slice(2));
+  if (
+    name.startsWith("react-native/") ||
+    nativePackages.some((pkg) => name === pkg || name.startsWith(`${pkg}/`))
+  ) {
+    context = {
+      ...context,
+      disableHierarchicalLookup: true,
+      nodeModulesPaths: [path.join(projectRoot, "node_modules")],
+    };
+  }
+  const result = resolveRequest(context, name, platform);
+  const replacement = Object.entries(fileAdapters).find(([suffix]) =>
+    result.filePath?.endsWith(suffix),
+  );
+  if (replacement)
+    return { type: "sourceFile", filePath: path.resolve(projectRoot, "adapters", replacement[1]) };
+  return result;
+};
+module.exports = config;

packages/app/gpui/desktop/src/NativePaseoDesktop.ts

@@ -0,0 +1,9 @@
+import { TurboModuleRegistry, type TurboModule } from "react-native";
+export interface Spec extends TurboModule {
+  sqlite(sql: string, params: string): string;
+  locale(): string;
+  timezone(): string;
+  sha256(text: string): string;
+  randomBytes(length: number): Array<number>;
+}
+export default TurboModuleRegistry.getEnforcing<Spec>("PaseoDesktop");

packages/app/gpui/desktop/src/main.rs

@@ -0,0 +1,29 @@
+rn_gpui_module::include_specs!();
+
+mod services;
+
+fn main() {
+    react_native_gpui::register_module(native_paseo_desktop_module::<services::PaseoDesktop>());
+    rn_gpui_autolink::ensure_linked();
+    // A debug build knows where its own bundle is; a release build does not, and
+    // must not: the path would name the machine that built it. A packaged release
+    // app resolves the bundle beside its executable instead.
+    #[cfg(debug_assertions)]
+    if std::env::var_os("RN_GPUI_BUNDLE").is_none() {
+        std::env::set_var("RN_GPUI_BUNDLE", env!("RN_GPUI_DEFAULT_BUNDLE"));
+    }
+    let config = react_native_gpui::DesktopAppConfig::from_env_with_defaults(
+        env!("RN_GPUI_APP_NAME"),
+        env!("RN_GPUI_APP_ID"),
+    )
+    .window_title("Paseo GPUI")
+    .window_size(1024.0, 768.0)
+    .dev_menu(true)
+    .configure_window(|options| {
+        // GPUI window options are public: titlebar, resizability, display,
+        // decorations, min size, and other native window behavior.
+        options.is_resizable = true;
+    });
+
+    react_native_gpui::run_with(config);
+}

packages/app/gpui/desktop/src/services.rs

@@ -0,0 +1,174 @@
+use crate::{NativePaseoDesktopEvents, NativePaseoDesktopSpec};
+use rn_gpui_module::ModuleError;
+use std::io::Read;
+
+pub struct PaseoDesktop {
+    database: std::sync::Mutex<Option<rusqlite::Connection>>,
+}
+impl PaseoDesktop {
+    fn database(
+        &self,
+    ) -> Result<std::sync::MutexGuard<'_, Option<rusqlite::Connection>>, ModuleError> {
+        let mut guard = self
+            .database
+            .lock()
+            .map_err(|e| ModuleError::new(e.to_string()))?;
+        if guard.is_none() {
+            let base = std::env::var("XDG_DATA_HOME")
+                .map(std::path::PathBuf::from)
+                .unwrap_or_else(|_| {
+                    std::path::PathBuf::from(std::env::var("HOME").expect("HOME is set"))
+                        .join(".local/share")
+                });
+            let dir = base.join("paseo-gpui");
+            std::fs::create_dir_all(&dir).map_err(|e| ModuleError::new(e.to_string()))?;
+            *guard = Some(
+                rusqlite::Connection::open(dir.join("replica.db"))
+                    .map_err(|e| ModuleError::new(e.to_string()))?,
+            );
+        }
+        Ok(guard)
+    }
+}
+impl NativePaseoDesktopSpec for PaseoDesktop {
+    fn new(_events: NativePaseoDesktopEvents) -> Self {
+        Self {
+            database: std::sync::Mutex::new(None),
+        }
+    }
+    fn sqlite(&self, sql: String, params: String) -> Result<String, ModuleError> {
+        let fail = |e: rusqlite::Error| ModuleError::new(e.to_string());
+        let db = self.database()?;
+        let db = db.as_ref().unwrap();
+        if params == "batch" {
+            db.execute_batch(&sql).map_err(fail)?;
+            return Ok("[]".into());
+        }
+        let values: Vec<serde_json::Value> =
+            serde_json::from_str(&params).map_err(|e| ModuleError::new(e.to_string()))?;
+        let values: Vec<rusqlite::types::Value> = values
+            .into_iter()
+            .map(|v| match v {
+                serde_json::Value::Null => rusqlite::types::Value::Null,
+                serde_json::Value::String(v) => rusqlite::types::Value::Text(v),
+                serde_json::Value::Number(v) => v
+                    .as_i64()
+                    .map(rusqlite::types::Value::Integer)
+                    .unwrap_or_else(|| rusqlite::types::Value::Real(v.as_f64().unwrap())),
+                _ => rusqlite::types::Value::Text(v.to_string()),
+            })
+            .collect();
+        let mut stmt = db.prepare(&sql).map_err(fail)?;
+        let names: Vec<String> = stmt.column_names().into_iter().map(str::to_owned).collect();
+        let mut rows = stmt
+            .query(rusqlite::params_from_iter(values))
+            .map_err(fail)?;
+        let mut results = Vec::new();
+        while let Some(row) = rows.next().map_err(fail)? {
+            let mut object = serde_json::Map::new();
+            for (index, name) in names.iter().enumerate() {
+                let value = match row.get_ref(index).map_err(fail)? {
+                    rusqlite::types::ValueRef::Null => serde_json::Value::Null,
+                    rusqlite::types::ValueRef::Integer(v) => v.into(),
+                    rusqlite::types::ValueRef::Real(v) => serde_json::json!(v),
+                    rusqlite::types::ValueRef::Text(v) => {
+                        String::from_utf8_lossy(v).into_owned().into()
+                    }
+                    rusqlite::types::ValueRef::Blob(_) => {
+                        return Err(ModuleError::new(
+                            "Replica store does not support blob columns",
+                        ))
+                    }
+                };
+                object.insert(name.clone(), value);
+            }
+            results.push(object);
+        }
+        serde_json::to_string(&results).map_err(|e| ModuleError::new(e.to_string()))
+    }
+    fn timezone(&self) -> Result<String, ModuleError> {
+        if let Ok(zone) = std::env::var("TZ") {
+            if !zone.is_empty() {
+                return Ok(zone.trim_start_matches(':').into());
+            }
+        }
+        if let Ok(path) = std::fs::read_link("/etc/localtime") {
+            if let Some((_, zone)) = path.to_string_lossy().split_once("/zoneinfo/") {
+                return Ok(zone.into());
+            }
+        }
+        Ok(std::fs::read_to_string("/etc/timezone")
+            .map(|s| s.trim().into())
+            .unwrap_or_else(|_| "UTC".into()))
+    }
+    fn locale(&self) -> Result<String, ModuleError> {
+        Ok(["LC_ALL", "LC_MESSAGES", "LANG"]
+            .iter()
+            .find_map(|key| std::env::var(key).ok().filter(|v| !v.is_empty()))
+            .unwrap_or_else(|| "en_US.UTF-8".into()))
+    }
+    fn sha256(&self, text: String) -> Result<String, ModuleError> {
+        use sha2::{Digest, Sha256};
+        Ok(format!("{:x}", Sha256::digest(text.as_bytes())))
+    }
+    fn random_bytes(&self, length: f64) -> Result<Vec<f64>, ModuleError> {
+        if !length.is_finite() || length < 0.0 || length > 65536.0 || length.fract() != 0.0 {
+            return Err(ModuleError::new("Invalid random byte count"));
+        }
+        let mut bytes = vec![0u8; length as usize];
+        std::fs::File::open("/dev/urandom")
+            .and_then(|mut source| source.read_exact(&mut bytes))
+            .map_err(|error| ModuleError::new(error.to_string()))?;
+        Ok(bytes.into_iter().map(f64::from).collect())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn service() -> PaseoDesktop {
+        PaseoDesktop {
+            database: std::sync::Mutex::new(Some(rusqlite::Connection::open_in_memory().unwrap())),
+        }
+    }
+    #[test]
+    fn crypto_matches_sha256_and_bounds_random_requests() {
+        let service = service();
+        assert_eq!(
+            service.sha256("abc".into()).unwrap(),
+            "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+        );
+        assert_eq!(service.random_bytes(32.0).unwrap().len(), 32);
+        assert!(service.random_bytes(65537.0).is_err());
+        assert!(service.random_bytes(-1.0).is_err());
+    }
+    #[test]
+    fn replica_transactions_bind_values_and_roll_back() {
+        let service = service();
+        service
+            .sqlite(
+                "CREATE TABLE rows (key TEXT PRIMARY KEY, value TEXT);".into(),
+                "batch".into(),
+            )
+            .unwrap();
+        service
+            .sqlite(
+                "INSERT INTO rows VALUES (?, ?)".into(),
+                r#"["key","quoted ' value"]"#.into(),
+            )
+            .unwrap();
+        service
+            .sqlite(
+                "BEGIN IMMEDIATE; DELETE FROM rows; ROLLBACK;".into(),
+                "batch".into(),
+            )
+            .unwrap();
+        let result = service
+            .sqlite("SELECT key, value FROM rows".into(), "[]".into())
+            .unwrap();
+        assert_eq!(
+            serde_json::from_str::<serde_json::Value>(&result).unwrap(),
+            serde_json::json!([{"key":"key","value":"quoted ' value"}])
+        );
+    }
+}

packages/app/gpui/index.js

@@ -0,0 +1,10 @@
+/* oxlint-disable import/no-unassigned-import -- Install globals before app modules evaluate. */
+import "./adapters/intl";
+import "../src/polyfills/install-early";
+import "../src/styles/unistyles";
+import { AppRegistry } from "react-native";
+import { RootApp } from "../src/root-app";
+
+// GPUI owns the native surface. Keep Paseo's full router and providers, while
+// leaving Expo's mobile registration and WebView-based dev overlay out.
+AppRegistry.registerComponent("Paseo", () => RootApp);

packages/app/gpui/native.test.ts

@@ -0,0 +1,103 @@
+import { afterAll, beforeAll, expect, test } from "vitest";
+
+// Runs against the actual Paseo bundle in the compiled GPUI app. Start with
+// RN_GPUI_TEST_DRIVER=1 and pass its loopback URL and token to this test.
+const endpoint = process.env.PASEO_GPUI_TEST_URL;
+const token = process.env.PASEO_GPUI_TEST_TOKEN;
+let socket: WebSocket;
+let nextId = 0;
+interface Node {
+  tag: number;
+  component: string;
+  testID: string;
+  text: string;
+  children?: Node[];
+}
+const pending = new Map<number, { resolve(value: unknown): void; reject(error: Error): void }>();
+function request<T = unknown>(method: string, params: Record<string, unknown> = {}): Promise<T> {
+  const id = ++nextId;
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      pending.delete(id);
+      reject(new Error(`GPUI ${method} timed out`));
+    }, 15_000);
+    pending.set(id, {
+      resolve: (value) => {
+        clearTimeout(timer);
+        resolve(value as T);
+      },
+      reject: (error) => {
+        clearTimeout(timer);
+        reject(error);
+      },
+    });
+    socket.send(JSON.stringify({ jsonrpc: "2.0", id, method, params: { ...params, token } }));
+  });
+}
+function flatten(node: Node): Node[] {
+  return [node, ...(node.children ?? []).flatMap(flatten)];
+}
+async function nodes() {
+  return (await request<{ children: Node[] }>("tree")).children.flatMap(flatten);
+}
+beforeAll(async () => {
+  if (!endpoint) return;
+  if (!token) throw new Error("PASEO_GPUI_TEST_TOKEN is required");
+  socket = new WebSocket(endpoint);
+  await new Promise<void>((resolve, reject) => {
+    socket.addEventListener("open", () => resolve(), { once: true });
+    socket.addEventListener("error", () => reject(new Error("GPUI driver connection failed")), {
+      once: true,
+    });
+  });
+  socket.addEventListener("message", (event) => {
+    const response = JSON.parse(String(event.data));
+    const waiter = pending.get(response.id);
+    if (!waiter) return;
+    pending.delete(response.id);
+    const error = response.error ?? response.result?.error;
+    if (error) waiter.reject(new Error(JSON.stringify(error)));
+    else waiter.resolve(response.result);
+  });
+});
+afterAll(() => socket?.close());
+
+test.skipIf(!endpoint)(
+  "real Paseo portal passes workspace clicks and the native composer edits text",
+  async () => {
+    const workspace = (await nodes()).find((node) =>
+      node.testID.startsWith("sidebar-workspace-row-"),
+    );
+    expect(workspace, "connected daemon must have an existing workspace").toBeDefined();
+    // Regression: the upstream box-none portal hit area intercepted this click.
+    expect(await request("click", { tag: workspace!.tag })).toEqual({ clicked: true });
+    await expect
+      .poll(async () => (await nodes()).some((node) => node.testID === "workspace-header-title"), {
+        timeout: 15_000,
+      })
+      .toBe(true);
+    await expect
+      .poll(async () => (await nodes()).some((node) => node.component === "TextInput"), {
+        timeout: 15_000,
+      })
+      .toBe(true);
+    const input = (await nodes()).find((node) => node.component === "TextInput")!;
+    const original = (await request<{ text: string }>("getProps", { tag: input.tag })).text;
+    try {
+      await request("click", { tag: input.tag });
+      await request("press", { key: "ctrl-a" });
+      await request("press", { key: "backspace" });
+      expect(
+        await request("type", { tag: input.tag, text: "GPUI native input regression" }),
+      ).toEqual({ typed: true });
+      await expect
+        .poll(async () => (await request<{ text: string }>("getProps", { tag: input.tag })).text)
+        .toBe("GPUI native input regression");
+    } finally {
+      await request("press", { key: "ctrl-a" });
+      await request("press", { key: "backspace" });
+      if (original) await request("type", { tag: input.tag, text: original });
+    }
+  },
+  45_000,
+);

packages/app/gpui/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "paseo-gpui",
+  "version": "0.0.0",
+  "private": true,
+  "dependencies": {
+    "@formatjs/intl-datetimeformat": "^7.9.0",
+    "@formatjs/intl-displaynames": "^7.4.0",
+    "@formatjs/intl-getcanonicallocales": "^3.3.0",
+    "@formatjs/intl-locale": "^5.4.1",
+    "@formatjs/intl-numberformat": "^9.5.0",
+    "@formatjs/intl-pluralrules": "^6.4.0",
+    "@formatjs/intl-segmenter": "^12.3.0",
+    "@react-native-gpui/codegen": "file:../../../vendor/react-native-gpui/packages/codegen",
+    "@react-native-gpui/core": "file:../../../vendor/react-native-gpui/packages/core",
+    "@react-native-gpui/fs": "file:../../../vendor/react-native-gpui/modules/fs",
+    "@react-native-gpui/gesture-handler": "file:../../../vendor/react-native-gpui/modules/gesture-handler",
+    "@react-native-gpui/hermes": "file:../../../vendor/react-native-gpui/packages/hermes",
+    "@react-native-gpui/reanimated": "file:../../../vendor/react-native-gpui/modules/reanimated",
+    "@react-native-gpui/safe-area-context": "file:../../../vendor/react-native-gpui/modules/safe-area-context",
+    "@react-native-gpui/screens": "file:../../../vendor/react-native-gpui/modules/screens",
+    "@react-native-gpui/svg": "file:../../../vendor/react-native-gpui/modules/svg",
+    "@react-native-gpui/worklets": "file:../../../vendor/react-native-gpui/modules/worklets",
+    "@react-native/assets-registry": "^0.87.1",
+    "react": "19.2.3",
+    "react-native": "0.87.1",
+    "react-native-gesture-handler": "3.3.0",
+    "react-native-reanimated": "https://github.com/ammarahm-ed/react-native-reanimated/releases/download/4.7.1-desktop.1/react-native-reanimated-4.7.1.tgz",
+    "react-native-safe-area-context": "5.10.1",
+    "react-native-screens": "4.28.0",
+    "react-native-svg": "15.15.5",
+    "react-native-worklets": "https://github.com/ammarahm-ed/react-native-reanimated/releases/download/worklets-0.13.0-desktop.1/react-native-worklets-0.13.0.tgz"
+  },
+  "devDependencies": {
+    "@react-native-community/cli": "20.2.0",
+    "@react-native-gpui/cli": "file:../../../vendor/react-native-gpui/packages/cli",
+    "@react-native/babel-preset": "0.87.1",
+    "@react-native/metro-config": "0.87.1",
+    "typescript": "^5.8.3"
+  }
+}

packages/app/gpui/react-native-gpui-env.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="@react-native-gpui/core/types" />
+// Added by react-native-gpui. Do not edit: it is regenerated.

packages/app/gpui/react-native.config.js

@@ -0,0 +1,17 @@
+const path = require("node:path");
+module.exports = {
+  // This target only launches desktop. RN CLI 20.2's built-in
+  // run-ios/run-android option lists conflict with the CLI's global verbose
+  // option, and this app has no native mobile projects to launch.
+  commands: ["build-android", "build-ios", "log-android", "log-ios", "run-android", "run-ios"].map(
+    (name) => ({
+      name,
+      description: `${name} is not configured for Paseo GPUI`,
+      func: () => {
+        throw new Error(`${name} is not configured for Paseo GPUI`);
+      },
+    }),
+  ),
+  project: { desktop: {} },
+  reactNativePath: path.dirname(require.resolve("react-native/package.json")),
+};

packages/app/gpui/routes.js

@@ -0,0 +1,7 @@
+// Use the existing route tree. Expo's transformer normally supplies this root
+// through a Babel caller field; the RN desktop transformer does not.
+export const ctx = require.context(
+  "../src/app",
+  true,
+  /^(?:\.\/)(?!(?:(?:(?:.*\+api)|(?:\+(html|native-intent))))\.[tj]sx?$).*\.[tj]sx?$/,
+);

packages/app/gpui/rust-toolchain.toml

@@ -0,0 +1,3 @@
+[toolchain]
+channel = "stable"
+profile = "minimal"

packages/app/src/agent-commands/cache/index.ts

@@ -1,8 +1,16 @@
 import type { QueryClient } from "@tanstack/react-query";
 import type { AgentProvider } from "@getpaseo/protocol/agent-types";
+import type { ProviderSnapshotEntry } from "@getpaseo/protocol/agent-types";
+import equal from "fast-deep-equal";
 import { normalizeWorkspacePath } from "@/utils/workspace-identity";
 
 export const AGENT_COMMANDS_QUERY_ROOT = "agentCommands";
+export const sessionCommandQueryPolicy = {
+  staleTime: 600_000,
+  gcTime: 1_800_000,
+  refetchOnMount: true,
+  refetchOnWindowFocus: false,
+} as const;
 
 export interface AgentCommandsDraftConfig {
   provider: AgentProvider;
@@ -21,6 +29,46 @@ export function agentCommandsQueryRoot(serverId: string) {
   return [AGENT_COMMANDS_QUERY_ROOT, serverId] as const;
 }
 
+/** Snapshot announcements contain provider metadata, not command catalogs. Ignore initial
+ * discovery and unrelated providers; explicit refresh still invalidates every catalog. */
+export function invalidateCommandsForProviderChange(input: {
+  queryClient: QueryClient;
+  serverId: string;
+  cwd: string | null;
+  previous: readonly ProviderSnapshotEntry[] | undefined;
+  current: readonly ProviderSnapshotEntry[];
+}): Promise<void> {
+  const previous = new Map((input.previous ?? []).map((entry) => [entry.provider, entry]));
+  const current = new Map(input.current.map((entry) => [entry.provider, entry]));
+  const relevant = (entry: ProviderSnapshotEntry | undefined) =>
+    entry && {
+      status: entry.status,
+      enabled: entry.enabled,
+      source: entry.source,
+      models: entry.models,
+      modes: entry.modes,
+      defaultModeId: entry.defaultModeId,
+    };
+  return input.queryClient.invalidateQueries({
+    queryKey: agentCommandsQueryRoot(input.serverId),
+    predicate: (query) => {
+      const isDraft = query.queryKey[2] === "draft";
+      const provider =
+        query.meta?.agentCommandProvider ?? (isDraft ? query.queryKey[6] : undefined);
+      const cwd = query.meta?.agentCommandCwd ?? (isDraft ? query.queryKey[4] : undefined);
+      if (input.cwd && typeof cwd === "string" && normalizeAgentCommandsCwd(cwd) !== input.cwd)
+        return false;
+      if (typeof provider !== "string") return false;
+      const before = previous.get(provider);
+      const after = current.get(provider);
+      if (!before) return after?.status === "ready" && query.state.status === "error";
+      if (before.status !== "ready")
+        return after?.status === "ready" && query.state.status === "error";
+      return !equal(relevant(before), relevant(after));
+    },
+  });
+}
+
 export function sessionAgentCommandsQueryKey(input: { serverId: string; agentId: string }) {
   return [...agentCommandsQueryRoot(input.serverId), "session", input.agentId] as const;
 }

packages/app/src/agent-commands/index.tsx

@@ -0,0 +1,99 @@
+import { createContext, useCallback, useContext, useMemo, type ReactNode } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import type { ComposerEditingSession } from "@/composer/editing-session";
+import { agentCommandsQueryKey } from "./cache";
+import {
+  useAgentCommandsQuery,
+  type AgentSlashCommand,
+  type DraftCommandConfig,
+} from "./use-query";
+
+export type {
+  AgentSlashCommand,
+  DraftCommandConfig,
+  DraftCommandTarget,
+  AgentCommandsClient,
+} from "./use-query";
+export { fetchAgentCommands } from "./use-query";
+
+type CommandQuery = ReturnType<typeof useAgentCommandsQuery>;
+const QueryContext = createContext<CommandQuery | null>(null);
+export interface CommandHints {
+  names: ReadonlySet<string>;
+  insert(command: string): void;
+}
+const HintsContext = createContext<CommandHints | null>(null);
+
+function useLiveAgentCommands() {
+  return useContext(QueryContext);
+}
+export function useAutocompleteCommands(input: {
+  serverId: string;
+  agentId: string;
+  enabled: boolean;
+  draftConfig?: DraftCommandConfig;
+}) {
+  const live = useLiveAgentCommands();
+  const fallback = useAgentCommandsQuery({
+    serverId: input.serverId,
+    agentId: input.agentId,
+    enabled: !live && input.enabled,
+    draftConfig: input.draftConfig,
+  });
+  return live ?? fallback;
+}
+export function useAgentCommandHints() {
+  return useContext(HintsContext);
+}
+export function matchCommandLink(
+  url: string,
+  sourceType: "markdown" | "text" | "inline-code" | undefined,
+  names: ReadonlySet<string>,
+): string | null {
+  return (sourceType === "markdown" || sourceType === "inline-code") &&
+    url.startsWith("/") &&
+    names.has(url.slice(1))
+    ? url
+    : null;
+}
+
+export function AgentCommandsProvider({
+  serverId,
+  agentId,
+  editingSession,
+  enabled,
+  children,
+}: {
+  serverId: string;
+  agentId: string;
+  editingSession: ComposerEditingSession;
+  enabled: boolean;
+  children: ReactNode;
+}) {
+  const query = useAgentCommandsQuery({ serverId, agentId, enabled });
+  const queryClient = useQueryClient();
+  const namesKey = JSON.stringify(
+    [...new Set(query.commands.map((command) => command.name))].sort(),
+  );
+  const names = useMemo<ReadonlySet<string>>(
+    () => new Set(JSON.parse(namesKey) as string[]),
+    [namesKey],
+  );
+  const insert = useCallback(
+    (token: string) => {
+      const commands = queryClient.getQueryData<AgentSlashCommand[]>(
+        agentCommandsQueryKey({ serverId, agentId }),
+      );
+      if (token.startsWith("/") && commands?.some((command) => `/${command.name}` === token)) {
+        editingSession.insertCommand(token);
+      }
+    },
+    [agentId, editingSession, queryClient, serverId],
+  );
+  const hints = useMemo(() => ({ names, insert }), [names, insert]);
+  return (
+    <QueryContext.Provider value={enabled ? query : null}>
+      <HintsContext.Provider value={enabled ? hints : null}>{children}</HintsContext.Provider>
+    </QueryContext.Provider>
+  );
+}

packages/app/src/agent-commands/query.test.ts

@@ -1,11 +1,61 @@
 import { describe, expect, it } from "vitest";
+import { QueryClient, QueryObserver } from "@tanstack/react-query";
+import { fetchQueryOptions } from "@/data/query";
 import {
   agentCommandsQueryKey,
   agentCommandsQueryRoot,
   draftAgentCommandsQueryKey,
   normalizeAgentCommandsCwd,
   sessionAgentCommandsQueryKey,
-} from "./agent-commands-query";
+  sessionCommandQueryPolicy,
+} from "./cache";
+
+it("reuses fresh commands and keeps stale commands during a shared refresh and failure", async () => {
+  const client = new QueryClient({ defaultOptions: { queries: { gcTime: 300_000 } } });
+  const key = sessionAgentCommandsQueryKey({ serverId: "s", agentId: "a" });
+  let calls = 0;
+  let fail = false;
+  let resolveRefresh: (value: string[]) => void = () => {};
+  const refresh = new Promise<string[]>((resolve) => {
+    resolveRefresh = resolve;
+  });
+  const options = fetchQueryOptions({
+    ...sessionCommandQueryPolicy,
+    staleTimeMs: sessionCommandQueryPolicy.staleTime,
+    dataShape: "value",
+    queryKey: key,
+    retry: false,
+    queryFn: async () => {
+      calls++;
+      if (fail) throw new Error("offline");
+      return refresh;
+    },
+  });
+  client.setQueryData(key, ["old"]);
+  const fresh = new QueryObserver(client, options);
+  const unsubscribeFresh = fresh.subscribe(() => {});
+  expect(calls).toBe(0);
+  unsubscribeFresh();
+  client.setQueryData(key, ["old"], { updatedAt: 1 });
+  const first = new QueryObserver(client, options);
+  const second = new QueryObserver(client, options);
+  const unsubscribeFirst = first.subscribe(() => {});
+  const unsubscribeSecond = second.subscribe(() => {});
+  expect(calls).toBe(1);
+  expect(first.getCurrentResult().data).toEqual(["old"]);
+  expect(client.getQueryCache().find({ queryKey: key })?.gcTime).toBe(1_800_000);
+  resolveRefresh(["new"]);
+  await refresh;
+  await first.refetch({ cancelRefetch: false });
+  expect(second.getCurrentResult().data).toEqual(["new"]);
+  fail = true;
+  await client.invalidateQueries({ queryKey: key });
+  expect(first.getCurrentResult().data).toEqual(["new"]);
+  expect(first.getCurrentResult().isError).toBe(true);
+  unsubscribeFirst();
+  unsubscribeSecond();
+  client.clear();
+});
 
 describe("agent command query keys", () => {
   it("shares draft commands across draft tabs with the same provider setup", () => {

packages/app/src/agent-commands/use-query.test.ts

@@ -1,9 +1,5 @@
 import { describe, expect, it } from "vitest";
-import {
-  type AgentCommandsClient,
-  type DraftCommandConfig,
-  fetchAgentCommands,
-} from "./use-agent-commands-query";
+import { type AgentCommandsClient, type DraftCommandConfig, fetchAgentCommands } from "./use-query";
 
 type ListCommands = AgentCommandsClient["listCommands"];
 type ListCommandsResult = Awaited<ReturnType<ListCommands>>;
@@ -38,6 +34,12 @@ function commandsPayload(commands: ListCommandsResult["commands"]): ListCommands
 }
 
 describe("fetchAgentCommands", () => {
+  it("rejects a discovery error so a previous catalog is retained", async () => {
+    const client = createClient({ ...commandsPayload([]), error: "provider unavailable" });
+    await expect(fetchAgentCommands({ client, agentId: "agent-1" })).rejects.toThrow(
+      "provider unavailable",
+    );
+  });
   it("loads commands for a draft composer without an agent id", async () => {
     const client = createClient(
       commandsPayload([{ name: "compact", description: "Compact context", argumentHint: "" }]),

packages/app/src/agent-commands/use-query.ts

@@ -1,12 +1,15 @@
-import { useQuery } from "@tanstack/react-query";
+import { useFetchQuery } from "@/data/query";
 import { useTranslation } from "react-i18next";
 import type { DaemonClient } from "@getpaseo/client/internal/daemon-client";
 import { useRetainedPanelActive } from "@/components/retained-panel";
+import { useSessionStore } from "@/stores/session-store";
+import { useShallow } from "zustand/shallow";
 import { useHostRuntimeClient, useHostRuntimeIsConnected } from "@/runtime/host-runtime";
-import { agentCommandsQueryKey, type AgentCommandsDraftConfig } from "@/hooks/agent-commands-query";
-
-const DRAFT_COMMANDS_STALE_TIME = Number.POSITIVE_INFINITY;
-const SESSION_COMMANDS_STALE_TIME = 60_000;
+import {
+  agentCommandsQueryKey,
+  sessionCommandQueryPolicy,
+  type AgentCommandsDraftConfig,
+} from "./cache";
 
 export interface AgentSlashCommand {
   name: string;
@@ -41,6 +44,7 @@ export async function fetchAgentCommands(input: {
     agentId: input.agentId,
     draftConfig: input.draftConfig,
   });
+  if (response.error) throw new Error(response.error);
   return response.commands as AgentSlashCommand[];
 }
 
@@ -62,8 +66,16 @@ export function useAgentCommandsQuery({
   const queryEnabled = enabled && retainedPanelActive;
   const client = useHostRuntimeClient(serverId);
   const isConnected = useHostRuntimeIsConnected(serverId);
+  const { provider, cwd } = useSessionStore(
+    useShallow((state) => {
+      const agent =
+        state.sessions[serverId]?.agents?.get(agentId) ??
+        state.sessions[serverId]?.agentDetails?.get(agentId);
+      return { provider: agent?.provider, cwd: agent?.cwd };
+    }),
+  );
 
-  const query = useQuery({
+  const query = useFetchQuery({
     queryKey: agentCommandsQueryKey({ serverId, agentId, draftConfig }),
     queryFn: async () => {
       if (!client) {
@@ -72,7 +84,15 @@ export function useAgentCommandsQuery({
       return fetchAgentCommands({ client, agentId, draftConfig });
     },
     enabled: queryEnabled && !!client && isConnected && (!!agentId || !!draftConfig),
-    staleTime: draftConfig ? DRAFT_COMMANDS_STALE_TIME : SESSION_COMMANDS_STALE_TIME,
+    dataShape: "value",
+    meta: {
+      agentCommandProvider: draftConfig?.provider ?? provider,
+      agentCommandCwd: draftConfig?.cwd ?? cwd,
+    },
+    ...(draftConfig
+      ? { immutableWhen: () => true as const }
+      : { ...sessionCommandQueryPolicy, staleTimeMs: sessionCommandQueryPolicy.staleTime }),
+    subscribed: queryEnabled,
     retry: 3,
     retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 5000),
   });
@@ -84,7 +104,7 @@ export function useAgentCommandsQuery({
   return {
     commands: query.data ?? [],
     isLoading,
-    isError: query.isError,
+    isError: query.isError && query.data === undefined,
     error: query.error,
   };
 }

packages/app/src/components/markdown/images.ts

@@ -35,11 +35,15 @@ export interface MarkdownImageContext {
   filePath?: string;
 }
 
-export function useMarkdownSource(text: string, context: MarkdownImageContext) {
+export function useMarkdownSource(
+  text: string,
+  context: MarkdownImageContext,
+  commandNames?: ReadonlySet<string>,
+) {
   const occurrenceKey = useId();
   const prepared = useMemo(
-    () => prepareMarkdownSource(text, context.workspaceRoot, { supportsSvg: isWeb }),
-    [text, context.workspaceRoot],
+    () => prepareMarkdownSource(text, context.workspaceRoot, { supportsSvg: isWeb, commandNames }),
+    [text, context.workspaceRoot, commandNames],
   );
   const sources = [...new Set(prepared.images.map((image) => image.source))];
   const acquisitions = sources.map((source) => {

packages/app/src/components/markdown/renderer.test.ts

@@ -2,6 +2,8 @@ import { fromMarkdown } from "mdast-util-from-markdown";
 import { toNativeLinkRecognition } from "react-native-enriched-markdown/src/utils/regexParser";
 import { parseMarkdown } from "react-native-enriched-markdown/src/web/parseMarkdown";
 import { recognizeTextLinks } from "react-native-enriched-markdown/src/web/recognizeTextLinks";
+import { matchCommandLink } from "@/agent-commands";
+
 import { classifyAssistantFileLink } from "@/assistant-file-links";
 import { markInlineImages } from "react-native-enriched-markdown/src/web/utils";
 import type { ASTNode } from "react-native-enriched-markdown/src/web/types";
@@ -13,6 +15,28 @@ import { createMarkdownStyles } from "./styles";
 import { prepareMarkdownSource, PENDING_MARKDOWN_IMAGE } from "./source";
 import { normalizeMarkdownHtml } from "./html";
 
+it("recognizes complete known commands in inline code", () => {
+  const names = new Set(["code-review", "review:fast"]);
+  const prepared = prepareMarkdownSource("`/code-review` `/unknown`", undefined, {
+    commandNames: names,
+  });
+  expect(prepared.linkRecognition.inlineCode.test("/code-review")).toBe(true);
+  expect(prepared.linkRecognition.inlineCode.test("/unknown")).toBe(
+    prepareMarkdownSource("`/unknown`").linkRecognition.inlineCode.test("/unknown"),
+  );
+  const nonPath = prepareMarkdownSource("`/review:fast`", undefined, { commandNames: names });
+  expect(nonPath.linkRecognition.inlineCode.test("/review:fast")).toBe(true);
+  expect(matchCommandLink("/code-review", "inline-code", names)).toBe("/code-review");
+});
+
+it("resolves authored root-relative links only when the target is a known command", () => {
+  const names = new Set(["code-review"]);
+  expect(matchCommandLink("/code-review", "markdown", names)).toBe("/code-review");
+  expect(matchCommandLink("/code-review/file", "markdown", names)).toBeNull();
+  expect(matchCommandLink("/code-review", "text", names)).toBeNull();
+  expect(matchCommandLink("https://example.com/code-review", "markdown", names)).toBeNull();
+});
+
 describe("shared Markdown source adaptation", () => {
   it("keeps paragraphs, fences and quotes together for the library", () => {
     const source = "First paragraph.\n\nSecond paragraph.\n\n```ts\nconst n = 1;\n```\n\n> Quote";

packages/app/src/components/markdown/renderer.tsx

@@ -6,6 +6,7 @@ import {
   useAssistantFileLinkEnvironment,
 } from "@/assistant-file-links";
 import { useStableEvent } from "@/hooks/use-stable-event";
+import { matchCommandLink, useAgentCommandHints, type CommandHints } from "@/agent-commands";
 import { AttachmentLightbox, type ImageLightboxSource } from "@/components/attachment-lightbox";
 import type { Theme } from "@/styles/theme";
 import { isWeb } from "@/constants/platform";
@@ -48,6 +49,7 @@ export interface MarkdownRendererProps extends MarkdownImageContext {
   selectable?: boolean;
   streaming?: boolean;
   onLinkPress?: (url: string) => unknown;
+  agentCommands?: boolean;
 }
 
 /** All Markdown surfaces share the same engine and source adaptation. */
@@ -59,15 +61,21 @@ export const MarkdownRenderer = memo(function MarkdownRenderer(props: MarkdownRe
     () => splitStreamingMarkdown(completeLines, true).head.length,
     [completeLines],
   );
-  if (!streaming || boundary === 0) return <MarkdownPart {...props} />;
+  const Part = props.agentCommands ? CommandMarkdownPart : MarkdownPart;
+  if (!streaming || boundary === 0) return <Part {...props} />;
   return (
     <MarkdownBlockStack>
-      <MarkdownPart {...props} text={props.text.slice(0, boundary)} />
-      <MarkdownPart {...props} text={props.text.slice(boundary)} />
+      <Part {...props} text={props.text.slice(0, boundary)} />
+      <Part {...props} text={props.text.slice(boundary)} />
     </MarkdownBlockStack>
   );
 });
 
+const CommandMarkdownPart = memo(function CommandMarkdownPart(props: MarkdownRendererProps) {
+  const commandHints = useAgentCommandHints();
+  return <MarkdownPart {...props} commandHints={commandHints} />;
+});
+
 const MarkdownPart = memo(function MarkdownPart({
   text,
   compact = false,
@@ -75,8 +83,10 @@ const MarkdownPart = memo(function MarkdownPart({
   selectable = true,
   streaming = false,
   onLinkPress,
+  agentCommands: _agentCommands,
+  commandHints = null,
   ...imageContext
-}: MarkdownRendererProps) {
+}: MarkdownRendererProps & { commandHints?: CommandHints | null }) {
   const environment = useAssistantFileLinkEnvironment();
   const actions = useAssistantFileLinkActions();
   const client =
@@ -84,14 +94,23 @@ const MarkdownPart = memo(function MarkdownPart({
     (environment.client?.readFile
       ? { readFile: environment.client.readFile.bind(environment.client) }
       : undefined);
-  const { markdown, imageSources, linkRecognition, linkSource } = useMarkdownSource(text, {
-    workspaceRoot: environment.workspaceRoot,
-    serverId: environment.serverId,
-    ...imageContext,
-    client,
-  });
+  const { markdown, imageSources, linkRecognition, linkSource } = useMarkdownSource(
+    text,
+    {
+      workspaceRoot: environment.workspaceRoot,
+      serverId: environment.serverId,
+      ...imageContext,
+      client,
+    },
+    commandHints?.names,
+  );
   const [image, setImage] = useState<ImageLightboxSource | null>(null);
   const pressLink = useStableEvent(({ url, sourceType }: LinkPressEvent) => {
+    const command = commandHints && matchCommandLink(url, sourceType, commandHints.names);
+    if (command) {
+      commandHints.insert(command);
+      return;
+    }
     const source = linkSource(url, sourceType);
     if (onLinkPress && !actions.canResolveFile(source)) onLinkPress(url);
     else actions.open(source, "preferred");

packages/app/src/components/markdown/source.ts

@@ -56,7 +56,11 @@ function linkMetadata(inlineCodePaths: ReadonlySet<string>) {
   };
 }
 
-function collectInlineCodePaths(source: string, workspaceRoot?: string): ReadonlySet<string> {
+function collectInlineCodePaths(
+  source: string,
+  workspaceRoot?: string,
+  commandNames?: ReadonlySet<string>,
+): ReadonlySet<string> {
   const paths = new Set<string>();
   const previousEnds = new Map<number, number>();
   // Collect candidates between consecutive runs of equal length. The engine owns
@@ -74,7 +78,11 @@ function collectInlineCodePaths(source: string, workspaceRoot?: string): Readonl
       value = value.slice(1, -1);
     }
     const classification = classifyAssistantFileLink(value, { workspaceRoot });
-    if (classification && classification.kind !== "external") paths.add(value);
+    if (
+      (classification && classification.kind !== "external") ||
+      (value.startsWith("/") && commandNames?.has(value.slice(1)))
+    )
+      paths.add(value);
   }
   return paths;
 }
@@ -112,7 +120,7 @@ function workspaceHoverTitle(link: Link, markup: string, workspaceRoot?: string)
 export function prepareMarkdownSource(
   source: string,
   workspaceRoot?: string,
-  options: { supportsSvg?: boolean } = {},
+  options: { supportsSvg?: boolean; commandNames?: ReadonlySet<string> } = {},
 ) {
   source = normalizeMarkdownHtml(source);
   const images: MarkdownImage[] = [];
@@ -122,7 +130,9 @@ export function prepareMarkdownSource(
       extensions: [gfmTable()],
       mdastExtensions: [gfmTableFromMarkdown()],
     }));
-  const metadata = linkMetadata(collectInlineCodePaths(source, workspaceRoot));
+  const metadata = linkMetadata(
+    collectInlineCodePaths(source, workspaceRoot, options.commandNames),
+  );
   const edits: { start: number; end: number; text: string }[] = [];
   if (
     !source.includes("![") &&

packages/app/src/components/message.tsx

@@ -15,7 +15,7 @@ import { useRewindAgentMutation } from "@/components/rewind/use-rewind-agent-mut
 import { TaskListRow } from "@/components/task-list-row";
 import { LoadingSpinner } from "@/components/ui/loading-spinner";
 import { useIsCompactFormFactor } from "@/constants/layout";
-import { isNative, isWeb } from "@/constants/platform";
+import { isNative, isWeb, supportsMaskedEffects } from "@/constants/platform";
 import { useRevealedText, type MarkdownPhase } from "@/hooks/use-revealed-text";
 import { ICON_SIZE, type Theme } from "@/styles/theme";
 import { inlineUnistylesStyle } from "@/styles/unistyles-inline-style";
@@ -1199,6 +1199,7 @@ export const AssistantMessage = memo(function AssistantMessage({
     >
       <MarkdownRenderer
         text={revealedMessage}
+        agentCommands
         streaming={phase !== "complete" || revealedMessage.length < renderedMessage.text.length}
         client={client}
         workspaceRoot={workspaceRoot}
@@ -1799,7 +1800,7 @@ function computeShimmerMetrics(input: {
   // React Native Web only observes a node when onLayout exists at mount. Keep
   // measuring while idle so a retained badge has dimensions when it starts loading.
   const shouldMeasureWebShimmer = isWeb;
-  const shouldMeasureNativeShimmer = input.isLoading && isNative;
+  const shouldMeasureNativeShimmer = input.isLoading && isNative && supportsMaskedEffects;
   const isNativeShimmer =
     shouldMeasureNativeShimmer && input.labelRowWidth > 0 && input.labelRowHeight > 0;
   const webShimmerSpanStartX = input.labelOffsetX;

packages/app/src/composer/draft/input-draft.ts

@@ -2,7 +2,7 @@ import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import type { UserComposerAttachment } from "@/attachments/types";
 import type { TextReplacement } from "@/composer/types";
 import type { DraftAgentControlsProps } from "@/composer/agent-controls";
-import type { DraftCommandTarget } from "@/hooks/use-agent-commands-query";
+import type { DraftCommandTarget } from "@/agent-commands";
 import {
   useAgentFormState,
   type CreateAgentInitialValues,

packages/app/src/composer/editing-session/index.test.ts

@@ -2,6 +2,31 @@ import { describe, expect, it } from "vitest";
 import { ComposerEditingSession, ComposerEditingSessions } from "./index";
 
 describe("composer editing session", () => {
+  it("appends commands to the current editor buffer and focuses it", () => {
+    const session = new ComposerEditingSession();
+    let text = "draft typed since publication";
+    let focuses = 0;
+    let selection = { start: 0, end: 0 };
+    const detach = session.attachEditor({
+      getText: () => text,
+      replaceText: (next, nextSelection) => {
+        text = next;
+        selection = nextSelection;
+      },
+      focus: () => {
+        focuses += 1;
+      },
+    });
+    session.insertCommand("/review");
+    expect(selection).toEqual({ start: text.length, end: text.length });
+    session.insertCommand("/test");
+    expect(text).toBe("draft typed since publication /review /test ");
+    expect(focuses).toBe(2);
+    expect(selection).toEqual({ start: text.length, end: text.length });
+    detach();
+    session.insertCommand("/ignored");
+    expect(text).toBe("draft typed since publication /review /test ");
+  });
   it("publishes fullscreen changes once per transition", () => {
     const session = new ComposerEditingSession();
     const changes: boolean[] = [];

packages/app/src/composer/editing-session/index.tsx

@@ -30,10 +30,29 @@ export interface ComposerRetainedEditor {
  */
 export class ComposerEditingSession {
   private fullscreen = false;
+  private editor: {
+    getText(): string;
+    replaceText(text: string, selection: ComposerSelection): void;
+    focus(): void;
+  } | null = null;
   private retained: ComposerRetainedEditor | null = null;
   private listeners = new Set<() => void>();
   constructor(private readonly onChange?: () => void) {}
   getFullscreen = () => this.fullscreen;
+  attachEditor(editor: NonNullable<ComposerEditingSession["editor"]>) {
+    this.editor = editor;
+    return () => {
+      if (this.editor === editor) this.editor = null;
+    };
+  }
+  insertCommand(command: string) {
+    const editor = this.editor;
+    if (!editor) return;
+    const text = editor.getText();
+    const nextText = `${text}${text && !/\s$/.test(text) ? " " : ""}${command} `;
+    editor.replaceText(nextText, { start: nextText.length, end: nextText.length });
+    editor.focus();
+  }
   /** Called by the unmounting editor; the next mount of this session takes it. */
   retainEditor(retained: ComposerRetainedEditor) {
     this.retained = retained;

packages/app/src/composer/index.tsx

@@ -71,7 +71,7 @@ import {
 } from "./input/input";
 import type { ImageAttachment, MessagePayload, TextReplacement } from "./types";
 import { ICON_SIZE, type Theme } from "@/styles/theme";
-import type { DraftCommandTarget } from "@/hooks/use-agent-commands-query";
+import type { DraftCommandTarget } from "@/agent-commands";
 import { encodeImages } from "@/utils/encode-images";
 import { focusWithRetries } from "@/utils/web-focus";
 import {

packages/app/src/composer/input/input.tsx

@@ -1407,6 +1407,16 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
       [onChangeText, updateComposerHeightForText, updateLiveTextPresence],
     );
 
+    useLayoutEffect(
+      () =>
+        editingSession.attachEditor({
+          getText: () => textInputRef.current?.getText() ?? valueRef.current,
+          replaceText,
+          focus: () => textInputRef.current?.focus(),
+        }),
+      [editingSession, replaceText],
+    );
+
     useImperativeHandle(ref, () => ({
       focus: () => {
         textInputRef.current?.focus();

packages/app/src/constants/platform.ts

@@ -25,6 +25,9 @@ export const isWeb = Platform.OS === "web";
 /** iOS or Android — the JS runtime is React Native. */
 export const isNative = Platform.OS !== "web";
 
+/** Platforms with an alpha-mask compositor for decorative shimmer effects. */
+export const supportsMaskedEffects = ["web", "ios", "android"].includes(Platform.OS);
+
 /** Development build/runtime — true in Metro dev bundles, false in production. */
 export const isDev = Boolean((globalThis as { __DEV__?: boolean }).__DEV__);
 

packages/app/src/data/providers-snapshot.ts

@@ -8,7 +8,7 @@ import {
 } from "./provider-snapshot-cache";
 import { queryClient as singletonQueryClient } from "./query-client";
 import { replaceProviderSnapshotIcons } from "@/data/provider-icons";
-import { agentCommandsQueryRoot } from "@/hooks/agent-commands-query";
+import { agentCommandsQueryRoot } from "@/agent-commands/cache";
 import type { AgentProvider } from "@getpaseo/protocol/agent-types";
 import { normalizeWorkspacePath } from "@/utils/workspace-identity";
 

packages/app/src/data/push-router.ts

@@ -1,11 +1,12 @@
 import type { OwnedSubscription } from "@getpaseo/client";
+import type { ProviderSnapshotEntry } from "@getpaseo/protocol/agent-types";
 import type { Query, QueryCacheNotifyEvent, QueryClient, QueryKey } from "@tanstack/react-query";
 import type {
   ListTerminalsResponse,
   MutableDaemonConfig,
   SessionOutboundMessage,
 } from "@getpaseo/protocol/messages";
-import { agentCommandsQueryRoot } from "@/hooks/agent-commands-query";
+import { invalidateCommandsForProviderChange } from "@/agent-commands/cache";
 import { shareCheckoutDiff } from "@/git/diff-sharing";
 import { orderCheckoutDiffFiles } from "@/git/diff-order";
 import { daemonConfigQueryKey } from "@/data/daemon-config";
@@ -186,10 +187,10 @@ export async function applyProvidersSnapshotUpdate(input: {
   const snapshot = { ...input.message.payload, requestId: "providers_snapshot_update" };
   const cwd = normalizeProvidersSnapshotCwd(snapshot.cwd);
   const queryKey = providersSnapshotQueryKey(input.serverId, cwd);
-  const previous = input.queryClient.getQueryData<{ snapshotHash?: string }>(queryKey);
+  const previous = input.queryClient.getQueryData<{ entries: ProviderSnapshotEntry[] }>(queryKey);
   let announcement: typeof snapshot | undefined = snapshot;
   void input.queryClient.cancelQueries({ queryKey, exact: true });
-  await input.queryClient.fetchQuery({
+  const current = await input.queryClient.fetchQuery({
     queryKey,
     staleTime: 0,
     structuralSharing: false,
@@ -205,12 +206,13 @@ export async function applyProvidersSnapshotUpdate(input: {
       });
     },
   });
-  if (!snapshot.snapshotHash || previous?.snapshotHash !== snapshot.snapshotHash) {
-    void input.queryClient.invalidateQueries({
-      queryKey: agentCommandsQueryRoot(input.serverId),
-      exact: false,
-    });
-  }
+  void invalidateCommandsForProviderChange({
+    queryClient: input.queryClient,
+    serverId: input.serverId,
+    cwd,
+    previous: previous?.entries,
+    current: current.entries,
+  });
 }
 
 export function mountServerDataPushRouter(input: PushRouterInput): () => void {

packages/app/src/data/query.ts

@@ -27,7 +27,7 @@ type ReplicaQueryInput<TQueryFnData, TError, TData, TQueryKey extends QueryKey>
 
 type FetchQueryInput<TQueryFnData, TError, TData, TQueryKey extends QueryKey> = Omit<
   UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-  "initialData" | "placeholderData" | "queryFn" | "refetchOnMount" | "staleTime"
+  "initialData" | "placeholderData" | "queryFn" | "staleTime"
 > & {
   dataShape: "list" | "value";
   queryFn: QueryFnOption<TQueryFnData, TError, TData, TQueryKey>;
@@ -113,7 +113,7 @@ export function fetchQueryOptions<
         dataShape,
       },
     },
-    refetchOnMount: immutableWhen ? true : "always",
+    refetchOnMount: options.refetchOnMount ?? (immutableWhen ? true : "always"),
     staleTime: immutableWhen
       ? (query) =>
           query.state.data !== undefined && immutableWhen(query.state.data) ? Infinity : 0

packages/app/src/git/checkout-status-cache.test.ts

@@ -16,7 +16,7 @@ import {
   resolveWorkingDiffComparison,
   selectWorkingDiffComparison,
 } from "@/git/working-diff-comparison";
-import { draftAgentCommandsQueryKey } from "@/hooks/agent-commands-query";
+import { draftAgentCommandsQueryKey } from "@/agent-commands/cache";
 import {
   applyCheckoutStatusUpdateFromEvent,
   ensureCheckoutStatus,

packages/app/src/git/checkout-status-cache.ts

@@ -8,7 +8,7 @@ import {
   invalidatePrPaneTimelineForCheckout,
 } from "@/git/query-keys";
 import { type CheckoutPrStatusPayload, normalizeCheckoutPrStatusPayload } from "@/git/pr-status";
-import { resetDraftAgentCommandsForCheckout } from "@/hooks/agent-commands-query";
+import { resetDraftAgentCommandsForCheckout } from "@/agent-commands/cache";
 
 export type CheckoutStatusPayload = CheckoutStatusResponse["payload"];
 export type { CheckoutPrStatusPayload } from "@/git/pr-status";

packages/app/src/hooks/use-agent-autocomplete.ts

@@ -4,11 +4,11 @@ import type { TFunction } from "i18next";
 import { useTranslation } from "react-i18next";
 import type { AutocompleteOption } from "@/components/ui/autocomplete";
 import {
-  useAgentCommandsQuery,
+  useAutocompleteCommands,
   type AgentSlashCommand,
   type DraftCommandConfig,
   type DraftCommandTarget,
-} from "./use-agent-commands-query";
+} from "@/agent-commands";
 import { orderAutocompleteOptions } from "@/components/ui/autocomplete-utils";
 import { useAutocomplete } from "./use-autocomplete";
 import { useSessionStore } from "@/stores/session-store";
@@ -432,7 +432,7 @@ export function useAgentAutocomplete(input: UseAgentAutocompleteInput): AgentAut
     autocompleteCwd,
   });
 
-  const commandsQuery = useAgentCommandsQuery({
+  const commandsQuery = useAutocompleteCommands({
     serverId,
     agentId,
     enabled: mode === "command" && canLoadCommands && canListCommands,

packages/app/src/hooks/use-providers-snapshot.test.ts

@@ -1,4 +1,4 @@
-import { QueryClient } from "@tanstack/react-query";
+import { QueryClient, QueryObserver } from "@tanstack/react-query";
 import { beforeEach, describe, expect, it } from "vitest";
 
 import type { DaemonClient } from "@getpaseo/client/internal/daemon-client";
@@ -8,7 +8,7 @@ import {
   expandProviderSnapshot,
 } from "@getpaseo/protocol/provider-snapshot-codec";
 import type { CachedProviderSnapshot, ProviderSnapshotCache } from "@/data/provider-snapshot-cache";
-import { draftAgentCommandsQueryKey } from "@/hooks/agent-commands-query";
+import { draftAgentCommandsQueryKey, sessionAgentCommandsQueryKey } from "@/agent-commands/cache";
 import { providerSnapshotIcons } from "@/data/provider-icons";
 import { applyProvidersSnapshotUpdate, type ProvidersSnapshotUpdate } from "@/data/push-router";
 import {
@@ -363,6 +363,153 @@ describe("applyProvidersSnapshotUpdate", () => {
     };
   }
 
+  it("refreshes active commands only when their provider changes after discovery", async () => {
+    const key = sessionAgentCommandsQueryKey({ serverId, agentId: "agent-1" });
+    let requests = 0;
+    const observer = new QueryObserver(queryClient, {
+      queryKey: key,
+      queryFn: async () => {
+        requests++;
+        return [{ name: "review" }];
+      },
+      staleTime: Infinity,
+      meta: { agentCommandProvider: "codex", agentCommandCwd: "/repo-a" },
+    });
+    const unsubscribe = observer.subscribe(() => {});
+    await observer.refetch({ cancelRefetch: false });
+    expect(requests).toBe(1);
+    const codex = codexEntry("ready", [readyCodexModel]);
+    const other = { provider: "claude", status: "loading", enabled: true } as ProviderSnapshotEntry;
+    await applyProvidersSnapshotUpdate({
+      client: createClient(),
+      serverId,
+      queryClient,
+      message: updateMessage([codexEntry("loading"), other], "/repo-a"),
+    });
+    expect(requests).toBe(1);
+    await applyProvidersSnapshotUpdate({
+      client: createClient(),
+      serverId,
+      queryClient,
+      message: updateMessage([codex, other], "/repo-a"),
+    });
+    expect(requests).toBe(1);
+    await applyProvidersSnapshotUpdate({
+      client: createClient(),
+      serverId,
+      queryClient,
+      message: updateMessage([codex, { ...other, status: "ready" }], "/repo-a"),
+    });
+    expect(requests).toBe(1);
+    await applyProvidersSnapshotUpdate({
+      client: createClient(),
+      serverId,
+      queryClient,
+      message: updateMessage(
+        [
+          { ...codex, fetchedAt: "2026-01-01T00:00:02.000Z" },
+          { ...other, status: "ready" },
+        ],
+        "/repo-a",
+      ),
+    });
+    expect(requests).toBe(1);
+    queryClient.setQueryData(
+      providersSnapshotQueryKey(serverId, "/repo-b"),
+      providersSnapshot([codex]),
+    );
+    await applyProvidersSnapshotUpdate({
+      client: createClient(),
+      serverId,
+      queryClient,
+      message: updateMessage(
+        [codexEntry("ready", [{ ...readyCodexModel, label: "Other checkout" }])],
+        "/repo-b",
+      ),
+    });
+    expect(requests).toBe(1);
+    await applyProvidersSnapshotUpdate({
+      client: createClient(),
+      serverId,
+      queryClient,
+      message: updateMessage(
+        [
+          codexEntry("ready", [{ ...readyCodexModel, label: "Updated" }]),
+          { ...other, status: "ready" },
+        ],
+        "/repo-a",
+      ),
+    });
+    await observer.refetch({ cancelRefetch: false });
+    expect(requests).toBe(2);
+    unsubscribe();
+    queryClient.clear();
+  });
+
+  it("retries a failed command discovery when its provider first becomes ready", async () => {
+    const key = sessionAgentCommandsQueryKey({ serverId, agentId: "agent-1" });
+    let ready = false;
+    let requests = 0;
+    const observer = new QueryObserver(queryClient, {
+      queryKey: key,
+      queryFn: async () => {
+        requests++;
+        if (!ready) throw new Error("provider unavailable");
+        return [{ name: "review" }];
+      },
+      retry: false,
+      meta: { agentCommandProvider: "codex", agentCommandCwd: "/repo-a" },
+    });
+    const unsubscribe = observer.subscribe(() => {});
+    await observer.refetch({ cancelRefetch: false });
+    expect(observer.getCurrentResult().isError).toBe(true);
+    ready = true;
+    await applyProvidersSnapshotUpdate({
+      client: createClient(),
+      serverId,
+      queryClient,
+      message: updateMessage([codexEntry("ready", [readyCodexModel])], "/repo-a"),
+    });
+    await observer.refetch({ cancelRefetch: false });
+    expect(requests).toBe(2);
+    expect(observer.getCurrentResult().data).toEqual([{ name: "review" }]);
+    unsubscribe();
+    queryClient.clear();
+  });
+
+  it("refreshes again when its provider changes during an active refresh", async () => {
+    const key = sessionAgentCommandsQueryKey({ serverId, agentId: "agent-1" });
+    queryClient.setQueryData(key, [{ name: "old" }]);
+    let requests = 0;
+    const waiting = new Promise<{ name: string }[]>(() => {});
+    const observer = new QueryObserver(queryClient, {
+      queryKey: key,
+      queryFn: async () => (++requests === 1 ? waiting : [{ name: "new" }]),
+      staleTime: Infinity,
+      meta: { agentCommandProvider: "codex", agentCommandCwd: "/repo-a" },
+    });
+    const unsubscribe = observer.subscribe(() => {});
+    queryClient.setQueryData(
+      providersSnapshotQueryKey(serverId, "/repo-a"),
+      providersSnapshot([codexEntry("ready", [readyCodexModel])]),
+    );
+    const send = (label: string) =>
+      applyProvidersSnapshotUpdate({
+        client: createClient(),
+        serverId,
+        queryClient,
+        message: updateMessage([codexEntry("ready", [{ ...readyCodexModel, label }])], "/repo-a"),
+      });
+    await send("First change");
+    expect(requests).toBe(1);
+    await send("Second change");
+    expect(requests).toBe(2);
+    await observer.refetch({ cancelRefetch: false });
+    expect(observer.getCurrentResult().data).toEqual([{ name: "new" }]);
+    unsubscribe();
+    queryClient.clear();
+  });
+
   it("routes updates to the home query cache when the message carries no cwd", async () => {
     await applyProvidersSnapshotUpdate({
       client: createClient(),
@@ -455,6 +602,10 @@ describe("applyProvidersSnapshotUpdate", () => {
       draftConfig: { provider: "codex", cwd: "/repo-a" },
     });
     queryClient.setQueryData(commandsKey, [{ name: "compact", description: "", argumentHint: "" }]);
+    queryClient.setQueryData(
+      providersSnapshotQueryKey(serverId, "/repo-a"),
+      providersSnapshot([codexEntry("ready")]),
+    );
 
     await applyProvidersSnapshotUpdate({
       client: createClient(),

packages/app/src/panels/agent-panel.tsx

@@ -28,6 +28,7 @@ import { FileDropZone } from "@/components/file-drop/file-drop-zone";
 import { useRetainedPanelActive } from "@/components/retained-panel";
 import { RetainedChatContent } from "./retained-chat-content";
 import { Composer } from "@/composer";
+import { AgentCommandsProvider } from "@/agent-commands";
 import {
   useComposerEditingSession,
   useComposerFullscreen,
@@ -1255,7 +1256,7 @@ const ChatAgentReadyContent = memo(function ChatAgentReadyContent({
     </ChatSurface>
   );
 
-  return (
+  const content = (
     <RewindComposerRestoreProvider
       textSource={agentInputDraft.textSource}
       setText={agentInputDraft.replaceText}
@@ -1274,8 +1275,40 @@ const ChatAgentReadyContent = memo(function ChatAgentReadyContent({
       </View>
     </RewindComposerRestoreProvider>
   );
+  return wrapAgentCommandProvider({
+    enabled: showsComposer && hasActiveComposer,
+    serverId,
+    agentId,
+    editingSession: composerEditingSession,
+    children: content,
+  });
 });
 
+function wrapAgentCommandProvider({
+  enabled,
+  serverId,
+  agentId,
+  editingSession,
+  children,
+}: {
+  enabled: boolean;
+  serverId: string;
+  agentId: string;
+  editingSession: ComposerEditingSession;
+  children: ReactNode;
+}) {
+  return (
+    <AgentCommandsProvider
+      serverId={serverId}
+      agentId={agentId}
+      editingSession={editingSession}
+      enabled={enabled}
+    >
+      {children}
+    </AgentCommandsProvider>
+  );
+}
+
 function ChatSurface({
   children,
   disabled,

packages/app/src/provider-selection/provider-selection.ts

@@ -5,7 +5,7 @@ import type {
   ProviderSnapshotEntry,
 } from "@getpaseo/protocol/agent-types";
 import type { AgentProviderDefinition } from "@getpaseo/protocol/provider-manifest";
-import type { DraftCommandTarget } from "@/hooks/use-agent-commands-query";
+import type { DraftCommandTarget } from "@/agent-commands";
 import { i18n } from "@/i18n/i18next";
 import { compareMatchScores, scoreTextFields } from "@getpaseo/protocol/search/text-match";
 import { filterSelectableModels } from "./model-catalog";

packages/app/src/screens/startup-splash-screen.tsx

@@ -19,7 +19,7 @@ import { PaseoLogo } from "@/components/icons/paseo-logo";
 import { Button } from "@/components/ui/button";
 import { getDesktopDaemonLogs, type DesktopDaemonLogs } from "@/desktop/daemon/desktop-daemon";
 import { TitlebarDragRegion } from "@/components/desktop/titlebar-drag-region";
-import { isNative, isWeb } from "@/constants/platform";
+import { isNative, isWeb, supportsMaskedEffects } from "@/constants/platform";
 import { CODE_SURFACE_DATASET } from "@/styles/code-surface";
 
 interface StartupSplashScreenProps {
@@ -86,7 +86,11 @@ function LogoShimmer() {
     return <WebLogoShimmer color={theme.colors.foreground} />;
   }
 
-  return <NativeLogoShimmer color={theme.colors.foreground} />;
+  return supportsMaskedEffects ? (
+    <NativeLogoShimmer color={theme.colors.foreground} />
+  ) : (
+    <PaseoLogo size={LOGO_SIZE} color={theme.colors.foreground} />
+  );
 }
 
 function WebLogoShimmer({ color }: { color: string }) {

packages/app/tsconfig.json

@@ -13,5 +13,6 @@
     "expo-env.d.ts",
     "nativewind-env.d.ts",
     "react-native-web.d.ts"
-  ]
+  ],
+  "exclude": ["gpui"]
 }

packages/relay/src/e2e.test.ts

@@ -56,6 +56,9 @@ function spawnRelayDevServer(port: number): ChildProcess {
       wranglerCliPath,
       "dev",
       "--local",
+      // Exercise the local Durable Object, independent of production cutover routing.
+      "--var",
+      "PASEO_RELAY_UPSTREAM:",
       "--ip",
       "127.0.0.1",
       "--port",

packages/server/scripts/build-opencode-bridge-plugin.mjs

@@ -1,4 +1,4 @@
-import { mkdir } from "node:fs/promises";
+import { copyFile, mkdir } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -27,4 +27,10 @@ for (const directory of ["", "v2/"]) {
     target: "es2022",
     outfile: outputPath,
   });
+  if (directory === "v2/") {
+    await copyFile(
+      new URL("../src/server/agent/providers/opencode/v2/state.mjs", import.meta.url),
+      path.join(path.dirname(outputPath), "state.mjs"),
+    );
+  }
 }

packages/server/src/server/agent/agent-manager.test.ts

@@ -1220,6 +1220,74 @@ test("orders buffered pre-steer output before an immediately accepted steer", as
   }
 });
 
+test("a steer the provider names without echoing it can be rewound to", async () => {
+  // Claude takes a steered message into the running turn without echoing it back as a user
+  // message, so the id it minted for the message reaches the manager only through the admission.
+  class SilentSteeringSession extends SteeringTestSession {
+    override readonly capabilities = {
+      ...TEST_CAPABILITIES,
+      supportsRewindFiles: true,
+    };
+    rewindMessageIds: string[] = [];
+
+    override async steerActiveTurn(
+      _prompt: AgentPromptInput,
+      options: import("./agent-sdk-types.js").SteerActiveTurnOptions,
+    ): Promise<import("./agent-sdk-types.js").SteerResult> {
+      if (options.expectedTurnId !== `active-turn-${this.startCount}`) {
+        return { status: "unavailable" };
+      }
+      return { status: "accepted", providerMessageId: `provider-${options.clientMessageId}` };
+    }
+
+    override async revertFiles({ messageId }: { messageId: string }): Promise<void> {
+      this.rewindMessageIds.push(messageId);
+    }
+  }
+  const session = new SilentSteeringSession({ provider: "codex", cwd: process.cwd() });
+  const workdir = mkdtempSync(join(tmpdir(), "agent-manager-steer-rewind-"));
+  const manager = new AgentManager({
+    clients: {
+      codex: new (class extends TestAgentClient {
+        override async createSession(): Promise<AgentSession> {
+          return session;
+        }
+      })(),
+    },
+    logger,
+  });
+  let agentId: string | null = null;
+  try {
+    const agent = await manager.createAgent({ provider: "codex", cwd: workdir }, undefined, {
+      workspaceId: undefined,
+    });
+    agentId = agent.id;
+    const run = manager.streamAgent(agent.id, "initial");
+    void (async () => {
+      for await (const _event of run) {
+      }
+    })();
+    await manager.waitForAgentRunStart(agent.id);
+
+    await expect(
+      manager.steerAgentRun(agent.id, "steered", { clientMessageId: "steer-client" }),
+    ).resolves.toMatchObject({ status: "accepted" });
+    const row = manager
+      .fetchTimeline(agent.id, { limit: 0 })
+      .rows.find((candidate) => candidate.item.type === "user_message");
+    expect(row).toMatchObject({
+      providerMessageId: "provider-steer-client",
+      item: { text: "steered", clientMessageId: "steer-client" },
+    });
+
+    await manager.rewind(agent.id, "steer-client", "files");
+    expect(session.rewindMessageIds).toEqual(["provider-steer-client"]);
+  } finally {
+    if (agentId) await manager.closeAgent(agentId).catch(() => undefined);
+    rmSync(workdir, { recursive: true, force: true });
+  }
+});
+
 test("orders a concurrent replacement after a pending accepted steer", async () => {
   const entered = deferred<void>();
   const release = deferred<void>();

packages/server/src/server/agent/agent-manager.ts

@@ -3029,7 +3029,13 @@ export class AgentManager {
         expectedTurnId,
       });
       if (admission.status === "accepted") {
-        await this.recordAcceptedSteer(agent, prompt, options?.clientMessageId, expectedTurnId);
+        await this.recordAcceptedSteer(
+          agent,
+          prompt,
+          options?.clientMessageId,
+          expectedTurnId,
+          admission.providerMessageId,
+        );
       }
       return admission;
     });
@@ -3062,7 +3068,13 @@ export class AgentManager {
             expectedTurnId,
           });
           if (admission.status === "accepted") {
-            await this.recordAcceptedSteer(agent, prompt, options?.clientMessageId, expectedTurnId);
+            await this.recordAcceptedSteer(
+              agent,
+              prompt,
+              options?.clientMessageId,
+              expectedTurnId,
+              admission.providerMessageId,
+            );
           }
           return admission;
         })
@@ -3167,6 +3179,7 @@ export class AgentManager {
     prompt: AgentPromptInput,
     clientMessageId: string | undefined,
     expectedTurnId: string,
+    providerMessageId: string | undefined,
   ): Promise<void> {
     if (!clientMessageId) {
       return;
@@ -3174,6 +3187,7 @@ export class AgentManager {
     this.recordSubmittedPrompt(agent, prompt, clientMessageId, "accepted", {
       messageId: clientMessageId,
       turnId: expectedTurnId,
+      ...(providerMessageId ? { providerMessageId } : {}),
     });
     this.emitState(agent);
   }

packages/server/src/server/agent/agent-sdk-types.ts

@@ -208,7 +208,11 @@ export interface AgentSteerOptions extends AgentRunOptions {
   clearPendingPermissions?: boolean;
 }
 
-export type SteerResult = { status: "accepted" } | { status: "unavailable" };
+// providerMessageId names the steered message in the provider's own history, when the provider
+// mints one. Rewinding to the message needs it.
+export type SteerResult =
+  | { status: "accepted"; providerMessageId?: string }
+  | { status: "unavailable" };
 
 export interface SteerActiveTurnOptions extends AgentSteerOptions {
   expectedTurnId: string;

packages/server/src/server/agent/provider-runtime.ts

@@ -22,7 +22,12 @@ interface CreateAgentProviderRuntimeOptions {
 export async function createAgentProviderRuntime(
   options: CreateAgentProviderRuntimeOptions,
 ): Promise<AgentProviderRuntime> {
-  const bridge = new OpenCodeBridge({ paseoHome: options.paseoHome, logger: options.logger });
+  const configuredPort =
+    options.snapshotManager.runtimeSettings?.opencode?.env?.PASEO_OPENCODE_BRIDGE_PORT;
+  const port = configuredPort === undefined ? undefined : Number(configuredPort);
+  if (port !== undefined && (!Number.isInteger(port) || port < 1 || port > 65535))
+    throw new Error("PASEO_OPENCODE_BRIDGE_PORT must be an integer between 1 and 65535");
+  const bridge = new OpenCodeBridge({ paseoHome: options.paseoHome, logger: options.logger, port });
   try {
     await bridge.start();
     const snapshotManager = new ProviderSnapshotManager({

packages/server/src/server/agent/providers/acp-agent.ts

@@ -142,14 +142,26 @@ function assertChildWithPipes(
   }
 }
 
-// Node reports a failed spawn (missing binary or missing cwd) as a child
-// `error` event; without a listener it becomes an uncaught exception.
-function rejectOnSpawnError(child: ChildProcess, stderrChunks: string[]): Promise<never> {
+// Watch process failures as well as spawn errors: the SDK leaves initialize
+// pending when the child exits without replying. `close` waits for stderr to
+// drain, so the failure includes the launcher's diagnostic.
+function rejectOnProcessFailure(child: ChildProcess, stderrChunks: string[]): Promise<never> {
   return new Promise<never>((_, reject) => {
     child.once("error", (error) => {
       const stderr = stderrChunks.join("").trim();
       reject(new Error(stderr ? `${String(error)}\n${stderr}` : String(error)));
     });
+    child.once("close", (code, signal) => {
+      const stderr = stderrChunks.join("").trim();
+      const status = signal ? `signal ${signal}` : `exit code ${code ?? "unknown"}`;
+      reject(
+        new Error(
+          `ACP agent process exited before initialization completed (${status})${
+            stderr ? `\n${stderr}` : ""
+          }`,
+        ),
+      );
+    });
   });
 }
 
@@ -542,7 +554,7 @@ interface ACPProcessTransport {
   connection: ClientSideConnection;
   stderrChunks: string[];
   spawnReady: Promise<void>;
-  spawnError: Promise<never>;
+  processError: Promise<never>;
 }
 
 interface ACPImportPromptPreviews {
@@ -1380,6 +1392,7 @@ export class ACPAgentClient implements AgentClient {
       client?: ACPClient;
     },
   ): Promise<SpawnedACPProcess> {
+    const configuredOptions = ACPProviderOptionsSchema.parse(options?.providerOptions ?? {});
     const transport = await this.spawnTransport(launchEnv, options?.client);
     const probe: UninitializedACPProcess = {
       child: transport.child,
@@ -1391,7 +1404,7 @@ export class ACPAgentClient implements AgentClient {
       const initialize = await this.initializeTransport(
         transport,
         options?.initializeTimeoutMs,
-        options?.providerOptions,
+        configuredOptions.clientCapabilities,
       );
       const initializedProbe: SpawnedACPProcess = {
         ...probe,
@@ -1425,7 +1438,7 @@ export class ACPAgentClient implements AgentClient {
       stderrChunks.push(chunk.toString());
     });
 
-    const spawnErrorPromise = rejectOnSpawnError(child, stderrChunks);
+    const processErrorPromise = rejectOnProcessFailure(child, stderrChunks);
     const spawnReadyPromise = new Promise<void>((resolve) => {
       child.once("spawn", () => {
         resolve();
@@ -1444,16 +1457,15 @@ export class ACPAgentClient implements AgentClient {
       connection,
       stderrChunks,
       spawnReady: spawnReadyPromise,
-      spawnError: spawnErrorPromise,
+      processError: processErrorPromise,
     };
   }
 
   protected async initializeTransport(
     transport: ACPProcessTransport,
     initializeTimeoutMs?: number,
-    providerOptions?: Record<string, unknown>,
+    clientCapabilities?: ACPClientCapabilities,
   ): Promise<InitializeResponse> {
-    const configuredOptions = ACPProviderOptionsSchema.parse(providerOptions ?? {});
     let timeout: ReturnType<typeof setTimeout> | null = null;
     const initializeTimeoutPromise = initializeTimeoutMs
       ? new Promise<never>((_, reject) => {
@@ -1470,11 +1482,11 @@ export class ACPAgentClient implements AgentClient {
             protocolVersion: PROTOCOL_VERSION,
             clientCapabilities: buildACPClientCapabilities(
               this.clientCapabilityMeta,
-              configuredOptions.clientCapabilities ?? this.clientCapabilities,
+              clientCapabilities ?? this.clientCapabilities,
             ),
             clientInfo: { name: "Paseo", version: "dev" },
           }),
-          transport.spawnError,
+          transport.processError,
           ...(initializeTimeoutPromise ? [initializeTimeoutPromise] : []),
         ]),
       );
@@ -1555,7 +1567,7 @@ export class ACPAgentClient implements AgentClient {
       try {
         transport = await this.spawnTransport(PROBE_ENV);
         await withTimeout(
-          Promise.race([transport.spawnReady, transport.spawnError]),
+          Promise.race([transport.spawnReady, transport.processError]),
           phaseTimeoutMs,
           `ACP spawn timed out after ${phaseTimeoutMs}ms`,
         );
@@ -2910,7 +2922,7 @@ export class ACPAgentSession implements AgentSession, ACPClient {
     child.stderr.on("data", (chunk: Buffer | string) => {
       stderrChunks.push(chunk.toString());
     });
-    const spawnError = rejectOnSpawnError(child, stderrChunks);
+    const processError = rejectOnProcessFailure(child, stderrChunks);
     child.once("exit", (code, signal) => {
       if (this.closed || this.historyRuntimeReleased) {
         return;
@@ -2947,7 +2959,7 @@ export class ACPAgentSession implements AgentSession, ACPClient {
           ),
           clientInfo: { name: "Paseo", version: "dev" },
         }),
-        spawnError,
+        processError,
       ]),
     );
 

packages/server/src/server/agent/providers/acp-startup-exit.test.ts

@@ -0,0 +1,112 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { describe, expect, test } from "vitest";
+
+import { GenericACPAgentClient } from "./generic-acp-agent.js";
+import { createTestLogger } from "../../../test-utils/test-logger.js";
+
+// Exercise the public catalog API with a real child, including stdout EOF and
+// stderr draining. No provider installation or external service is involved.
+const failingCommand: [string, ...string[]] = [
+  process.execPath,
+  "-e",
+  "process.stdin.once('data', () => { process.stderr.write('launcher failed: fixture startup error\\n'); process.exitCode = 1; process.stdin.destroy(); });",
+];
+
+describe("ACP catalog startup failures", () => {
+  test("reports a process that exits during initialize with its stderr", async () => {
+    const client = new GenericACPAgentClient({
+      logger: createTestLogger(),
+      command: failingCommand,
+    });
+    await expect(
+      client.fetchCatalog({ scope: "workspace", cwd: process.cwd(), force: true }),
+    ).rejects.toThrow(/launcher failed: fixture startup error/);
+  }, 5_000);
+
+  test("session startup reports the same process exit with its stderr", async () => {
+    const client = new GenericACPAgentClient({
+      logger: createTestLogger(),
+      command: failingCommand,
+    });
+    await expect(client.createSession({ provider: "acp", cwd: process.cwd() })).rejects.toThrow(
+      /launcher failed: fixture startup error/,
+    );
+  }, 5_000);
+
+  test("provider diagnostics report the startup exit instead of an initialize timeout", async () => {
+    const client = new GenericACPAgentClient({
+      logger: createTestLogger(),
+      command: failingCommand,
+      diagnosticPhaseTimeoutMs: 2_000,
+    });
+    const { diagnostic } = await client.getDiagnostic();
+    expect(diagnostic).toContain(
+      "ACP agent process exited before initialization completed (exit code 1)",
+    );
+    expect(diagnostic).toContain("launcher failed: fixture startup error");
+    expect(diagnostic).not.toContain("initialize timed out");
+  });
+
+  test("invalid provider options reject without crashing the host process", async () => {
+    const clientModule = new URL("./generic-acp-agent.ts", import.meta.url).href;
+    const loggerModule = new URL("../../../test-utils/test-logger.ts", import.meta.url).href;
+    const script = `
+      import { GenericACPAgentClient } from ${JSON.stringify(clientModule)};
+      import { createTestLogger } from ${JSON.stringify(loggerModule)};
+      const client = new GenericACPAgentClient({
+        logger: createTestLogger(),
+        command: [process.execPath, '-e', 'setInterval(() => {}, 1000)'],
+      });
+      try {
+        await client.fetchCatalog({
+          scope: 'workspace', cwd: process.cwd(), force: true,
+          providerOptions: { clientCapabilities: { fs: 'invalid' } },
+        });
+        throw new Error('Expected invalid options to reject');
+      } catch (error) {
+        if (error.name !== 'ZodError') throw error;
+      }
+      // Let child cleanup and Node's unhandled-rejection check complete.
+      await new Promise(resolve => setTimeout(resolve, 100));
+      console.log('host stayed alive');
+    `;
+    const result = await promisify(execFile)(
+      process.execPath,
+      ["--import", "tsx", "--input-type=module", "-e", script],
+      { timeout: 10_000 },
+    );
+    expect(result.stdout).toContain("host stayed alive");
+    expect(result.stderr).toBe("");
+  });
+
+  test("a successful catalog probe still returns its models and closes cleanly", async () => {
+    const client = new GenericACPAgentClient({
+      logger: createTestLogger(),
+      command: [
+        process.execPath,
+        "-e",
+        `
+        require('node:readline').createInterface({ input: process.stdin }).on('line', (line) => {
+          const request = JSON.parse(line);
+          const result = request.method === 'initialize'
+            ? { protocolVersion: 1, agentCapabilities: {} }
+            : { sessionId: 'fixture', models: {
+                currentModelId: 'fixture-model',
+                availableModels: [{ modelId: 'fixture-model', name: 'Fixture model' }]
+              } };
+          process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, result }) + '\\n');
+        });
+      `,
+      ],
+    });
+    const catalog = await client.fetchCatalog({
+      scope: "workspace",
+      cwd: process.cwd(),
+      force: true,
+    });
+    expect(catalog.models).toEqual([
+      expect.objectContaining({ id: "fixture-model", label: "Fixture model" }),
+    ]);
+  });
+});

packages/server/src/server/agent/providers/claude/agent.history-load.test.ts

@@ -614,6 +614,43 @@ describe("ClaudeAgentSession persisted history load", () => {
     );
   });
 
+  test("replays a message steered into a running turn as the user's message", async () => {
+    const queued = (commandMode: string, prompt: unknown, sourceUuid?: string) => ({
+      type: "attachment",
+      uuid: `attachment-${commandMode}`,
+      parentUuid: "a1",
+      attachment: {
+        type: "queued_command",
+        commandMode,
+        prompt,
+        ...(sourceUuid ? { source_uuid: sourceUuid } : {}),
+      },
+    });
+    const entries = [
+      { type: "user", uuid: "u1", parentUuid: null, message: { content: "first" } },
+      { type: "assistant", uuid: "a1", parentUuid: "u1", message: { content: "working" } },
+      queued("prompt", [{ type: "text", text: "steered while working" }], "steered-1"),
+      queued("task-notification", "<task-notification><task-id>t1</task-id></task-notification>"),
+      { type: "assistant", uuid: "a2", parentUuid: "a1", message: { content: "answer" } },
+    ];
+    mkdirSync(path.dirname(transcriptPath()), { recursive: true });
+    writeFileSync(transcriptPath(), entries.map((entry) => JSON.stringify(entry)).join("\n"));
+
+    const session = await resume();
+    try {
+      const users = [];
+      for await (const event of session.streamHistory()) {
+        if (event.type === "timeline" && event.item.type === "user_message") users.push(event.item);
+      }
+      expect(users).toEqual([
+        { type: "user_message", text: "first", messageId: "u1" },
+        { type: "user_message", text: "steered while working", messageId: "steered-1" },
+      ]);
+    } finally {
+      await session.close();
+    }
+  });
+
   test("loads readable history when the temporary directory is unavailable", async () => {
     const file = transcriptPath();
     const entry = { type: "assistant", message: { content: [{ type: "text", text: "saved" }] } };

packages/server/src/server/agent/providers/claude/agent.interrupt-restart-regression.test.ts

@@ -349,8 +349,11 @@ async function startSteeredTurn(sessionId: string): Promise<{
     expectedTurnId: start.value.turnId,
     clientMessageId: "steer-client",
   });
-  expect(steered).toEqual({ status: "accepted" });
   await waitFor(() => query?.prompts.length === 2);
+  expect(steered).toEqual({
+    status: "accepted",
+    providerMessageId: query?.prompts[1]?.uuid,
+  });
 
   return { session, query: () => query, turn };
 }
@@ -972,7 +975,10 @@ test("steers an autonomous turn through its existing query without restarting it
   const steeredTimeline = await autonomousEvents.next();
   const completion = await autonomousEvents.next();
 
-  expect(steer).toEqual({ status: "accepted" });
+  expect(steer).toEqual({
+    status: "accepted",
+    providerMessageId: queryRef?.prompts[1]?.uuid,
+  });
   expect(queryFactory).toHaveBeenCalledTimes(1);
   expect(queryRef?.interrupt).not.toHaveBeenCalled();
   expect(queryRef?.prompts.map((prompt) => prompt.text)).toEqual(["seed prompt", "steer prompt"]);

packages/server/src/server/agent/providers/claude/agent.rewind-anchors.test.ts

@@ -1,7 +1,11 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
 import { describe, expect, test, vi } from "vitest";
 
 import { createTestLogger } from "../../../../test-utils/test-logger.js";
 import { ClaudeAgentClient } from "./agent.js";
+import { claudeProjectDir } from "./project-dir.js";
 import { FakeClaudeSdk } from "./test-rewind-claude-sdk.js";
 import { streamSession } from "../test-utils/session-stream-adapter.js";
 import type { AgentSession } from "../../agent-sdk-types.js";
@@ -267,3 +271,49 @@ describe("Claude rewind after a turn whose last assistant message came from a su
     expect(rewindSdk.recordedForks).toEqual([{ upToMessageId: "assistant-1" }]);
   });
 });
+
+describe("Claude rewind to a message steered into a running turn", () => {
+  test("forks at the entry Claude read the message after", async () => {
+    const configDir = mkdtempSync(path.join(tmpdir(), "claude-rewind-steer-"));
+    const previousConfigDir = process.env.CLAUDE_CONFIG_DIR;
+    process.env.CLAUDE_CONFIG_DIR = configDir;
+    const conversation = createConversation([{ assistantMessageId: "assistant-1" }]);
+    const rewindSdk = new FakeClaudeSdk();
+    const session = await createSession(conversation, rewindSdk);
+
+    try {
+      await runTurns(session, 1);
+      // A steered message opens no turn: Claude Code records it as a queued_command attachment
+      // under the uuid Paseo minted for it, hung off the entry it was read after.
+      const projectDir = await claudeProjectDir(process.cwd(), { configDir });
+      mkdirSync(projectDir, { recursive: true });
+      const entries = [
+        { type: "user", uuid: conversation.userMessageIds[0], parentUuid: null },
+        { type: "assistant", uuid: "assistant-1", parentUuid: conversation.userMessageIds[0] },
+        { type: "user", uuid: "tool-result-1", parentUuid: "assistant-1" },
+        {
+          type: "attachment",
+          uuid: "queued-command-1",
+          parentUuid: "tool-result-1",
+          attachment: { type: "queued_command", source_uuid: "steered-message-1" },
+        },
+      ];
+      writeFileSync(
+        path.join(projectDir, `${SESSION_ID}.jsonl`),
+        entries.map((entry) => `${JSON.stringify(entry)}\n`).join(""),
+      );
+
+      await session.revertConversation?.({ messageId: "steered-message-1" });
+    } finally {
+      await session.close();
+      if (previousConfigDir === undefined) {
+        delete process.env.CLAUDE_CONFIG_DIR;
+      } else {
+        process.env.CLAUDE_CONFIG_DIR = previousConfigDir;
+      }
+      rmSync(configDir, { recursive: true, force: true });
+    }
+
+    expect(rewindSdk.recordedForks).toEqual([{ upToMessageId: "tool-result-1" }]);
+  });
+});

packages/server/src/server/agent/providers/claude/agent.test.ts

@@ -1224,16 +1224,17 @@ describe("ClaudeAgentSession features", () => {
       const iterator = input[Symbol.asyncIterator]();
       await expect(iterator.next()).resolves.toMatchObject({ value: { type: "user" } });
 
-      await expect(
-        session.steerActiveTurn?.("same turn follow-up", {
-          expectedTurnId: turnId,
-          clientMessageId: "steer-client-id",
-        }),
-      ).resolves.toEqual({ status: "accepted" });
+      const admission = await session.steerActiveTurn?.("same turn follow-up", {
+        expectedTurnId: turnId,
+        clientMessageId: "steer-client-id",
+      });
+      expect(admission).toEqual({ status: "accepted", providerMessageId: expect.any(String) });
+      if (admission?.status !== "accepted") throw new Error("Expected steer admission");
       await expect(iterator.next()).resolves.toMatchObject({
         value: {
           type: "user",
           priority: "next",
+          uuid: admission.providerMessageId,
           message: { content: [{ type: "text", text: "same turn follow-up" }] },
         },
       });
@@ -1291,7 +1292,7 @@ describe("ClaudeAgentSession features", () => {
           expectedTurnId: turnId,
           clearPendingPermissions: true,
         }),
-      ).resolves.toEqual({ status: "accepted" });
+      ).resolves.toEqual({ status: "accepted", providerMessageId: expect.any(String) });
       await expect(firstPermission).resolves.toMatchObject({
         behavior: "deny",
         interrupt: undefined,
@@ -1350,7 +1351,7 @@ describe("ClaudeAgentSession features", () => {
       const permission = internal.handlePermissionRequest("Write", {}, { toolUseID: "tool-1" });
       await expect(
         session.steerActiveTurn?.("system notification", { expectedTurnId: turnId }),
-      ).resolves.toEqual({ status: "accepted" });
+      ).resolves.toEqual({ status: "accepted", providerMessageId: expect.any(String) });
       expect(session.getPendingPermissions()).toHaveLength(1);
       const requestId = session.getPendingPermissions()[0]!.id;
       await session.respondToPermission(requestId, { behavior: "deny", message: "test cleanup" });

packages/server/src/server/agent/providers/claude/agent.ts

@@ -82,6 +82,7 @@ import { renderPromptAttachmentAsText } from "../../prompt-attachments.js";
 import { discoverClaudeModels } from "./model-discovery.js";
 import { claudeQuery, type ClaudeOptions, type ClaudeQueryFactory } from "./query.js";
 import {
+  findSteeredMessageParent,
   realClaudeRewindSdk,
   revertClaudeConversation,
   revertClaudeFiles,
@@ -2627,7 +2628,7 @@ class ClaudeAgentSession implements AgentSession {
       return { status: "unavailable" };
     }
     this.enqueueSteer(input, message, options.clearPendingPermissions === true);
-    return { status: "accepted" };
+    return { status: "accepted", ...(message.uuid ? { providerMessageId: message.uuid } : {}) };
   }
 
   private enqueueSteer(
@@ -3094,7 +3095,7 @@ class ClaudeAgentSession implements AgentSession {
 
   async revertConversation(input: { messageId: string }): Promise<void> {
     await this.ensureHistoryReady();
-    const target = this.resolveConversationRewindTarget(input.messageId);
+    const target = await this.resolveConversationRewindTarget(input.messageId);
     if (target.kind === "fresh-session") {
       this.startFreshConversationSession();
       return;
@@ -3429,12 +3430,24 @@ class ClaudeAgentSession implements AgentSession {
     return messageId;
   }
 
-  private resolveConversationRewindTarget(messageId: string): ClaudeConversationRewindTarget {
+  private async resolveConversationRewindTarget(
+    messageId: string,
+  ): Promise<ClaudeConversationRewindTarget> {
     const targetUserMessageId = this.resolveClaudeMessageId(messageId);
     const index = this.rewindTurnAnchors.findIndex(
       (anchor) => anchor.userMessageId === targetUserMessageId,
     );
     if (index < 0) {
+      // A message steered into a running turn opens no turn of its own.
+      const transcriptPath = this.claudeSessionId
+        ? await this.resolveHistoryPath(this.claudeSessionId)
+        : null;
+      const steerParent = transcriptPath
+        ? await findSteeredMessageParent(transcriptPath, targetUserMessageId)
+        : null;
+      if (steerParent) {
+        return { kind: "fork", messageId: steerParent };
+      }
       throw new Error(`Claude rewind target ${messageId} is not in the tracked conversation`);
     }
 
@@ -6431,6 +6444,10 @@ function convertClaudeHistoryEntryPreamble(
   if (entry.type === "user" && isSyntheticHistoryUserEntry(entry)) {
     return { shortCircuit: [] };
   }
+  const steeredPrompt = readSteeredPromptHistoryItem(entry);
+  if (steeredPrompt) {
+    return { shortCircuit: [steeredPrompt] };
+  }
   // Only user and assistant records are conversation turns. Claude Code 2.1.x also journals each
   // API request as `api-request-blob` records whose message replays the system context.
   if (entry.type !== "user" && entry.type !== "assistant") {
@@ -6457,6 +6474,21 @@ function isProviderImageMessage(item: AgentTimelineItem): boolean {
   return item.type === "assistant_message" && isProviderImageMarkdown(item.text);
 }
 
+/**
+ * A message steered into a running turn. Claude Code gives it no user entry: it records a
+ * queued_command attachment in prompt mode, under the uuid Paseo minted for the message, which is
+ * also what a rewind to it resolves. The other modes carry task notifications, not user messages.
+ */
+function readSteeredPromptHistoryItem(entry: ClaudeHistoryEntry): AgentTimelineItem | null {
+  if (entry.type !== "attachment") return null;
+  const attachment = toObjectRecord(entry.attachment);
+  if (attachment?.type !== "queued_command" || attachment.commandMode !== "prompt") return null;
+  const text = extractUserMessageText(attachment.prompt);
+  if (!text) return null;
+  const messageId = readTrimmedString(attachment.source_uuid);
+  return { type: "user_message", text, ...(messageId ? { messageId } : {}) };
+}
+
 export async function convertClaudeHistoryEntry(
   entry: ClaudeHistoryEntry,
   mapBlocks: (

packages/server/src/server/agent/providers/claude/rewind.test.ts

@@ -1,11 +1,20 @@
 import { randomUUID } from "node:crypto";
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import {
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  readlinkSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { afterEach, describe, expect, test } from "vitest";
 import type { Query } from "@anthropic-ai/claude-agent-sdk";
 
 import {
+  findSteeredMessageParent,
   revertClaudeConversation,
   revertClaudeConversationAndFiles,
   revertClaudeFiles,
@@ -217,4 +226,96 @@ describe("Claude rewind against the Claude SDK", () => {
       "first reply",
     ]);
   });
+
+  test("forks just before a message steered into a running turn", async () => {
+    tempRoot = mkdtempSync(path.join(tmpdir(), "claude-rewind-steer-"));
+    delete process.env.CLAUDE_CONFIG_DIR;
+    const projectDir = path.join(tempRoot, "projects", "-repo");
+    mkdirSync(projectDir, { recursive: true });
+    const sessionId = randomUUID();
+    const firstUser = randomUUID();
+    const toolUse = randomUUID();
+    const toolResult = randomUUID();
+    const steeredMessage = randomUUID();
+    const queuedCommand = randomUUID();
+    const transcriptPath = path.join(projectDir, `${sessionId}.jsonl`);
+    writeTranscript(transcriptPath, sessionId, [
+      { type: "user", uuid: firstUser, parentUuid: null, text: "first" },
+      { type: "assistant", uuid: toolUse, parentUuid: firstUser, text: "running a tool" },
+      { type: "user", uuid: toolResult, parentUuid: toolUse, text: "tool output" },
+      // What Claude Code writes when it reads a steered message between two tool calls.
+      JSON.stringify({
+        type: "attachment",
+        uuid: queuedCommand,
+        parentUuid: toolResult,
+        sessionId,
+        attachment: {
+          type: "queued_command",
+          prompt: [{ type: "text", text: "steered" }],
+          source_uuid: steeredMessage,
+        },
+      }),
+      { type: "assistant", uuid: randomUUID(), parentUuid: queuedCommand, text: "reply to steer" },
+    ]);
+
+    const parent = await findSteeredMessageParent(transcriptPath, steeredMessage);
+    expect(parent).toBe(toolResult);
+    expect(await findSteeredMessageParent(transcriptPath, randomUUID())).toBeNull();
+
+    let currentSessionId = sessionId;
+    await revertClaudeConversation({
+      sdk: realClaudeRewindSdk,
+      sessionId,
+      transcriptPath,
+      messageId: parent!,
+      setSessionId: (nextSessionId) => {
+        currentSessionId = nextSessionId;
+      },
+    });
+    expect(readMessageTexts(path.join(projectDir, `${currentSessionId}.jsonl`))).toEqual([
+      "first",
+      "running a tool",
+      "tool output",
+    ]);
+  });
 });
+
+test.runIf(process.platform === "linux")(
+  "releases the transcript descriptor after an early steer match",
+  async () => {
+    const artifacts = path.resolve(".artifacts");
+    mkdirSync(artifacts, { recursive: true });
+    const root = mkdtempSync(path.join(artifacts, "claude-rewind-descriptor-"));
+    const transcriptPath = path.join(root, "session.jsonl");
+    const matchingEntry = {
+      type: "attachment",
+      parentUuid: "before-steer",
+      attachment: { type: "queued_command", source_uuid: "steered-message" },
+    };
+    const unreadEntry = JSON.stringify({ type: "assistant", message: "x".repeat(1024) });
+    writeFileSync(
+      transcriptPath,
+      JSON.stringify(matchingEntry) + "\n" + (unreadEntry + "\n").repeat(1200),
+    );
+    const openDescriptors = () =>
+      readdirSync("/proc/self/fd").filter((descriptor) => {
+        try {
+          return readlinkSync(path.join("/proc/self/fd", descriptor)) === transcriptPath;
+        } catch (error) {
+          if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
+          throw error;
+        }
+      }).length;
+    try {
+      expect(openDescriptors()).toBe(0);
+      for (let attempt = 0; attempt < 5; attempt++) {
+        await expect(findSteeredMessageParent(transcriptPath, "steered-message")).resolves.toBe(
+          "before-steer",
+        );
+      }
+      await expect.poll(openDescriptors, { timeout: 1000 }).toBe(0);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  },
+);

packages/server/src/server/agent/providers/claude/rewind.ts

@@ -1,5 +1,7 @@
+import { createReadStream } from "node:fs";
 import { appendFile, readFile } from "node:fs/promises";
 import path from "node:path";
+import { createInterface } from "node:readline";
 import {
   forkSession as claudeForkSession,
   type Query,
@@ -70,6 +72,54 @@ function isSessionStoreEntry(value: unknown): value is SessionStoreEntry {
   );
 }
 
+/**
+ * The entry a message steered into a running turn follows. Claude Code gives such a message no
+ * entry of its own: it records a queued_command attachment, under the uuid Paseo minted for the
+ * message, hung off the entry it was read after. Forking at that entry drops the message and
+ * everything after it. Null when the transcript holds no such attachment.
+ */
+export async function findSteeredMessageParent(
+  transcriptPath: string,
+  messageId: string,
+): Promise<string | null> {
+  const input = createReadStream(transcriptPath, { encoding: "utf8" });
+  const lines = createInterface({
+    input,
+    crlfDelay: Infinity,
+  });
+  try {
+    for await (const line of lines) {
+      if (!line.includes(messageId) || !line.includes('"queued_command"')) continue;
+      let entry: unknown;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const record = entry as {
+        type?: unknown;
+        parentUuid?: unknown;
+        attachment?: { type?: unknown; source_uuid?: unknown };
+      };
+      if (
+        record.type === "attachment" &&
+        record.attachment?.type === "queued_command" &&
+        record.attachment.source_uuid === messageId &&
+        typeof record.parentUuid === "string"
+      ) {
+        return record.parentUuid;
+      }
+    }
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return null;
+    throw error;
+  } finally {
+    lines.close();
+    input.destroy();
+  }
+  return null;
+}
+
 export async function revertClaudeConversation(input: {
   sdk: ClaudeRewindSdk;
   sessionId: string | null;

packages/server/src/server/agent/providers/opencode-bridge-adapter.test.ts

@@ -80,8 +80,12 @@ describe("OpenCode bridge adapter", () => {
       await rm(paseoHome, { recursive: true, force: true });
     });
     const runtime = new TestOpenCodeHarness();
-    runtime.enqueueClient(new TestOpenCodeClient());
-    runtime.enqueueClient(new TestOpenCodeClient());
+    const envClient = new TestOpenCodeClient();
+    const mcpClient = new TestOpenCodeClient();
+    envClient.sessionCreateResponse = { data: { id: "ses_env" } };
+    mcpClient.sessionCreateResponse = { data: { id: "ses_mcp" } };
+    runtime.enqueueClient(envClient);
+    runtime.enqueueClient(mcpClient);
     const client = new OpenCodeAgentClient(createTestLogger(), undefined, {
       serverManager: runtime,
       createClient: runtime.createClient,
@@ -102,6 +106,12 @@ describe("OpenCode bridge adapter", () => {
     );
 
     expect(runtime.acquisitions.map(({ kind }) => kind)).toEqual(["dedicated", "dedicated"]);
+    await expect(readBridgeContext(bridge, "ses_env")).resolves.toEqual({
+      env: { PASEO_AGENT_ID: "one", CUSTOM_TOKEN: "secret" },
+    });
+    await expect(readBridgeContext(bridge, "ses_mcp")).resolves.toEqual({
+      env: { PASEO_AGENT_ID: "two" },
+    });
     await customEnv.close();
     await customMcp.close();
   });

packages/server/src/server/agent/providers/opencode/bridge.test.ts

@@ -20,6 +20,7 @@ import { createPaseoAgentToolManifest, createPaseoToolCatalog } from "../../tool
 import { serializePaseoToolInputParameters } from "../../tools/paseo-tool-serialization.js";
 import {
   OpenCodeBridge,
+  decorateOpenCodeV2Env,
   loadOpenCodeBridgePluginArtifact,
   materializeOpenCodeV2Plugin,
 } from "./bridge.js";
@@ -137,33 +138,28 @@ describe("OpenCodeBridge", () => {
       };
       expect(ajv.compile(createDefinition.inputSchema)(createInput)).toBe(true);
 
-      const v2Config = z
-        .object({ plugins: z.array(z.object({ package: z.string() })) })
-        .parse(JSON.parse((await bridge.decorateV2ServerEnv({})).OPENCODE_CONFIG_CONTENT));
-      const v2Module: {
-        default: { setup(context: V2TestPluginContext): Promise<() => Promise<void>> };
-      } = await import(
-        pathToFileURL(path.join(fileURLToPath(v2Config.plugins[0]!.package), "server.js")).href
-      );
       const tools = new Map<string, V2TestTool>();
-      const dispose = await v2Module.default.setup({
-        options: plugin,
-        tool: {
-          transform: async (transform) => {
-            transform({
-              add: (tool) => {
-                tools.set(tool.name, tool);
-              },
-            });
-            return { dispose: async () => undefined };
+      const dispose = await setupBoundV2Plugin(
+        bridge,
+        {
+          tool: {
+            transform: async (transform) => {
+              transform({
+                add: (tool) => {
+                  tools.set(tool.name, tool);
+                },
+              });
+              return { dispose: async () => undefined };
+            },
+          },
+          session: {
+            context: async () => [],
+            get: async () => ({ parentID: "bound" }),
+            hook: async () => ({ dispose: async () => undefined }),
           },
         },
-        session: {
-          context: async () => [],
-          get: async () => ({ parentID: "bound" }),
-          hook: async () => ({ dispose: async () => undefined }),
-        },
-      });
+        ["bound"],
+      );
       try {
         const created = await tools
           .get("paseo_create_agent")!
@@ -402,45 +398,35 @@ describe("OpenCodeBridge", () => {
     const release = bridge.bindSession({ sessionId: "parent", env: {}, tools: catalog });
     const releaseDisabled = bridge.bindSession({ sessionId: "disabled", env: {} });
     try {
-      const env = await bridge.decorateV2ServerEnv({});
-      const config = z
-        .object({
-          plugins: z.array(
-            z.object({
-              package: z.string(),
-              options: z.object({ baseUrl: z.string(), token: z.string() }),
-            }),
-          ),
-        })
-        .parse(JSON.parse(env.OPENCODE_CONFIG_CONTENT));
-      expect(await bridge.decorateV2ServerEnv(env)).toEqual(env);
-      const plugin = config.plugins[0]!;
+      const pluginUrl = await bridge.materializeV2Plugin();
+      const env = decorateOpenCodeV2Env({}, pluginUrl);
+      expect(decorateOpenCodeV2Env(env, pluginUrl)).toEqual(env);
       const tools = new Map<string, V2TestTool>();
       let filter!: (input: V2TestContext) => Promise<void>;
-      const module: {
-        default: { setup(context: V2TestPluginContext): Promise<() => Promise<void>> };
-      } = await import(pathToFileURL(path.join(fileURLToPath(plugin.package), "server.js")).href);
-      const dispose = await module.default.setup({
-        options: plugin.options,
-        tool: {
-          transform: async (transform) => {
-            transform({
-              add: (tool) => {
-                tools.set(tool.name, tool);
-              },
-            });
-            return { dispose: async () => undefined };
+      const dispose = await setupBoundV2Plugin(
+        bridge,
+        {
+          tool: {
+            transform: async (transform) => {
+              transform({
+                add: (tool) => {
+                  tools.set(tool.name, tool);
+                },
+              });
+              return { dispose: async () => undefined };
+            },
+          },
+          session: {
+            context: async () => [],
+            get: async ({ sessionID }) => ({ parentID: sessionID === "child" ? "parent" : "" }),
+            hook: async (_name, callback) => {
+              filter = callback;
+              return { dispose: async () => undefined };
+            },
           },
         },
-        session: {
-          context: async () => [],
-          get: async () => ({ parentID: "parent" }),
-          hook: async (_name, callback) => {
-            filter = callback;
-            return { dispose: async () => undefined };
-          },
-        },
-      });
+        ["parent", "disabled"],
+      );
       const allowed: V2TestContext = {
         sessionID: "child",
         tools: { paseo_echo_context: {}, native: {} },
@@ -453,6 +439,12 @@ describe("OpenCodeBridge", () => {
       };
       await filter(disabled);
       expect(Object.keys(disabled.tools)).toEqual(["native"]);
+      const unrelated: V2TestContext = {
+        sessionID: "unrelated",
+        tools: { paseo_echo_context: {}, native: {} },
+      };
+      await filter(unrelated);
+      expect(Object.keys(unrelated.tools)).toEqual(["native"]);
       await expect(
         tools.get("paseo_echo_context")!.execute({ value: "child result" }, { sessionID: "child" }),
       ).resolves.toMatchObject({ content: [{ type: "text", text: "child result" }] });
@@ -486,35 +478,33 @@ describe("OpenCodeBridge", () => {
     await bridge.start();
     const release = bridge.bindSession({ sessionId: "caller", env: {}, tools: catalog });
     try {
-      const env = await bridge.decorateV2ServerEnv({});
-      const { plugins } = JSON.parse(env.OPENCODE_CONFIG_CONTENT);
-      const plugin = plugins[0];
-      const module = await import(
-        pathToFileURL(path.join(fileURLToPath(plugin.package), "server.js")).href
-      );
+      const options = bridge.sharedV2Connection();
       const tools = new Map<string, V2TestTool>();
-      const dispose = await module.default.setup({
-        options: plugin.options,
-        tool: {
-          transform: async (transform: (editor: { add(tool: V2TestTool): void }) => void) => {
-            transform({ add: (tool) => tools.set(tool.name, tool) });
-            return { dispose: async () => undefined };
+      const dispose = await setupBoundV2Plugin(
+        bridge,
+        {
+          tool: {
+            transform: async (transform: (editor: { add(tool: V2TestTool): void }) => void) => {
+              transform({ add: (tool) => tools.set(tool.name, tool) });
+              return { dispose: async () => undefined };
+            },
+          },
+          session: {
+            context: async () => [],
+            get: async () => ({ parentID: "" }),
+            hook: async () => ({ dispose: async () => undefined }),
           },
         },
-        session: {
-          context: async () => [],
-          get: async () => ({ parentID: "" }),
-          hook: async () => ({ dispose: async () => undefined }),
-        },
-      } satisfies V2TestPluginContext);
+        ["caller"],
+      );
       try {
         const input = { provider: "codex", title: "Invalid provider", initialPrompt: "Hello" };
         const response = await fetch(
-          `${plugin.options.baseUrl}/_internal/opencode/sessions/caller/tools/create_agent`,
+          `${options.baseUrl}/_internal/opencode/sessions/caller/tools/create_agent`,
           {
             method: "POST",
             headers: {
-              Authorization: `Bearer ${plugin.options.token}`,
+              Authorization: `Bearer ${options.token}`,
               "Content-Type": "application/json",
             },
             body: JSON.stringify(input),
@@ -572,35 +562,24 @@ describe("OpenCodeBridge", () => {
     await bridge.start();
     const release = bridge.bindSession({ sessionId: "session", env: {}, tools: catalog });
     try {
-      const env = await bridge.decorateV2ServerEnv({});
-      const plugin = z
-        .object({
-          plugins: z.array(
-            z.object({
-              package: z.string(),
-              options: z.object({ baseUrl: z.string(), token: z.string() }),
-            }),
-          ),
-        })
-        .parse(JSON.parse(env.OPENCODE_CONFIG_CONTENT)).plugins[0]!;
       const pluginTools = new Map<string, V2TestTool>();
-      const module: {
-        default: { setup(context: V2TestPluginContext): Promise<() => Promise<void>> };
-      } = await import(pathToFileURL(path.join(fileURLToPath(plugin.package), "server.js")).href);
-      const dispose = await module.default.setup({
-        options: plugin.options,
-        tool: {
-          transform: async (transform) => {
-            transform({ add: (tool) => pluginTools.set(tool.name, tool) });
-            return { dispose: async () => undefined };
+      const dispose = await setupBoundV2Plugin(
+        bridge,
+        {
+          tool: {
+            transform: async (transform) => {
+              transform({ add: (tool) => pluginTools.set(tool.name, tool) });
+              return { dispose: async () => undefined };
+            },
+          },
+          session: {
+            context: async () => [],
+            get: async () => ({ parentID: undefined }),
+            hook: async () => ({ dispose: async () => undefined }),
           },
         },
-        session: {
-          context: async () => [],
-          get: async () => ({ parentID: undefined }),
-          hook: async () => ({ dispose: async () => undefined }),
-        },
-      });
+        ["session"],
+      );
       const result = await pluginTools
         .get("paseo_browser_screenshot")!
         .execute({}, { sessionID: "session" });
@@ -642,7 +621,8 @@ describe("OpenCodeBridge", () => {
     const tools = new Map<string, V2TestTool>();
     let hook!: (input: V2TestContext) => Promise<void>;
     const dispose = await module.default.setup({
-      options: { baseUrl: "", token: "" },
+      options: { mode: "structured-only" },
+      location: { directory: root },
       tool: {
         transform: async (transform) => {
           transform({
@@ -657,7 +637,7 @@ describe("OpenCodeBridge", () => {
         context: async () => history,
         get: async () => ({ parentID: "parent" }),
         hook: async (_name, callback) => {
-          hook = callback;
+          hook ??= callback;
           return { dispose: async () => undefined };
         },
       },
@@ -701,9 +681,13 @@ describe("OpenCodeBridge", () => {
           name.startsWith("paseo-v2-"),
         ),
       ).toEqual([]);
-      const env = await bridge.decorateV2ServerEnv({
-        OPENCODE_CONFIG_CONTENT: JSON.stringify({ plugins: ["user-plugin"] }),
-      });
+      const pluginUrl = await bridge.materializeV2Plugin();
+      const env = decorateOpenCodeV2Env(
+        {
+          OPENCODE_CONFIG_CONTENT: JSON.stringify({ plugins: ["user-plugin"] }),
+        },
+        pluginUrl,
+      );
       const config = z
         .object({ plugins: z.tuple([z.literal("user-plugin"), z.object({ package: z.string() })]) })
         .parse(JSON.parse(env.OPENCODE_CONFIG_CONTENT));
@@ -711,6 +695,9 @@ describe("OpenCodeBridge", () => {
       expect((await stat(directory)).isDirectory()).toBe(true);
       const entry = await readFile(path.join(directory, "server.js"), "utf8");
       expect(entry).toContain('id: "paseo"');
+      expect(await readFile(path.join(directory, "state.mjs"), "utf8")).toBe(
+        await readFile(new URL("./v2/state.mjs", import.meta.url), "utf8"),
+      );
       const manifest = JSON.parse(await readFile(path.join(directory, "package.json"), "utf8"));
       expect(manifest).toMatchObject({ type: "module", exports: { "./server": "./server.js" } });
     } finally {
@@ -856,7 +843,8 @@ interface V2TestContext {
   system?: Array<{ type: "text"; text: string }>;
 }
 interface V2TestPluginContext {
-  options: { baseUrl: string; token: string };
+  options: Record<string, string>;
+  location?: { directory: string };
   tool: {
     transform(
       callback: (editor: { add(tool: V2TestTool): void }) => void,
@@ -864,10 +852,33 @@ interface V2TestPluginContext {
   };
   session: {
     context(input: { sessionID: string }): Promise<SessionMessageInfo[]>;
-    get(input: { sessionID: string }): Promise<{ parentID: string }>;
+    get(input: { sessionID: string }): Promise<{ parentID: string | undefined }>;
     hook(
       name: string,
       callback: (input: V2TestContext) => Promise<void>,
     ): Promise<{ dispose(): Promise<void> }>;
   };
 }
+
+async function setupBoundV2Plugin(
+  bridge: OpenCodeBridge,
+  context: Pick<V2TestPluginContext, "tool" | "session">,
+  sessionIds: string[],
+): Promise<() => Promise<void>> {
+  const directory = fileURLToPath(await bridge.materializeV2Plugin());
+  const module = await import(pathToFileURL(path.join(directory, "server.js")).href);
+  let bind!: (input: { sessionID: string; baseUrl: string; token: string }) => Promise<unknown>;
+  const dispose: () => Promise<void> = await module.default.setup({
+    ...context,
+    options: {},
+    location: { directory },
+    rpc: {
+      register: async (_definition: unknown, handlers: { bind: typeof bind }) => {
+        bind = handlers.bind;
+        return { dispose: async () => undefined };
+      },
+    },
+  });
+  for (const sessionID of sessionIds) await bind({ sessionID, ...bridge.sharedV2Connection() });
+  return dispose;
+}

packages/server/src/server/agent/providers/opencode/bridge.ts

@@ -30,6 +30,7 @@ class OpenCodeBridgeClientError extends Error {
 interface OpenCodeBridgeOptions {
   paseoHome: string;
   logger: Logger;
+  port?: number;
 }
 
 interface OpenCodeSessionBinding {
@@ -54,6 +55,7 @@ interface OpenCodeConfig {
 export class OpenCodeBridge {
   private readonly paseoHome: string;
   private readonly logger: Logger;
+  private readonly port: number;
   private readonly token = randomBytes(32).toString("hex");
   private readonly sessions = new Map<string, OpenCodeSessionBinding>();
   private server: Server | null = null;
@@ -65,6 +67,7 @@ export class OpenCodeBridge {
   constructor(options: OpenCodeBridgeOptions) {
     this.paseoHome = options.paseoHome;
     this.logger = options.logger.child({ module: "agent", component: "opencode-bridge" });
+    this.port = options.port ?? 0;
   }
 
   async start(): Promise<void> {
@@ -75,7 +78,7 @@ export class OpenCodeBridge {
     });
     await new Promise<void>((resolve, reject) => {
       server.once("error", reject);
-      server.listen(0, "127.0.0.1", () => {
+      server.listen(this.port, "127.0.0.1", () => {
         server.off("error", reject);
         resolve();
       });
@@ -94,6 +97,8 @@ export class OpenCodeBridge {
   }
 
   bindSession(input: BindOpenCodeSessionInput): () => void {
+    if (this.sessions.has(input.sessionId))
+      throw new Error(`OpenCode session ${input.sessionId} is already bound to a Paseo agent`);
     const binding: OpenCodeSessionBinding = {
       env: { ...input.env },
       ...(input.tools ? { tools: input.tools } : {}),
@@ -127,12 +132,13 @@ export class OpenCodeBridge {
     };
   }
 
-  async decorateV2ServerEnv(env: Record<string, string>): Promise<Record<string, string>> {
+  async materializeV2Plugin(): Promise<string> {
     this.v2PluginUrl ??= await this.materializePlugin(2);
-    return decorateOpenCodeV2Env(env, this.v2PluginUrl, {
-      baseUrl: this.requireBaseUrl(),
-      token: this.token,
-    });
+    return this.v2PluginUrl;
+  }
+
+  sharedV2Connection(baseUrl = this.requireBaseUrl()): OpenCodePluginOptions {
+    return { baseUrl, token: this.token };
   }
 
   async close(): Promise<void> {
@@ -282,6 +288,8 @@ export async function materializeOpenCodeV2Plugin(paseoHome: string): Promise<st
   // V2 ignores configured file paths; it loads a package directory's server entry point.
   const directory = path.join(paseoHome, "runtime", "opencode", `paseo-v2-${digest}`);
   await writeFileAtomic(path.join(directory, "server.js"), artifact);
+  const state = await readFile(new URL("./v2/state.mjs", import.meta.url));
+  await writeFileAtomic(path.join(directory, "state.mjs"), state);
   await writeFileAtomic(
     path.join(directory, "package.json"),
     JSON.stringify({

packages/server/src/server/agent/providers/opencode/runtime-client.test.ts

@@ -66,6 +66,7 @@ test("retries a rejected version probe after the configured binary changes", asy
   const script = join(root, "version.cjs");
   const client = new OpenCodeRuntimeClient(createTestLogger(), {
     command: { mode: "replace", argv: [process.execPath, script] },
+    env: { XDG_STATE_HOME: root },
   });
   try {
     await writeFile(script, 'console.log("opencode v2.0.3")');
@@ -95,6 +96,7 @@ test.each([
   const script = join(root, "version.cjs");
   const client = new OpenCodeRuntimeClient(createTestLogger(), {
     command: { mode: "replace", argv: [process.execPath, script] },
+    env: { XDG_STATE_HOME: root },
   });
   try {
     await writeFile(script, initialSource);
@@ -193,6 +195,7 @@ test.each([
       logger,
       {
         command: { mode: "replace", argv: [process.execPath, script] },
+        env: { XDG_STATE_HOME: root },
       },
       { serverManager: new TrackedServerManager({ logger }) },
     );
@@ -209,3 +212,38 @@ test.each([
   },
   10000,
 );
+
+test("selects v2 without probing the binary when an external server is configured", async () => {
+  const { OpenCodeRuntimeClient } = await import("./runtime-client.js");
+  const { createTestLogger } = await import("../../../../test-utils/test-logger.js");
+  const client = new OpenCodeRuntimeClient(createTestLogger(), {
+    command: { mode: "replace", argv: [process.execPath, "-e", "process.exit(1)"] },
+    env: { PASEO_OPENCODE_SERVER_URL: "http://127.0.0.1:4096" },
+  });
+  try {
+    const features = await client.listFeatures({ provider: "opencode", cwd: "/tmp/project" });
+    expect(features.map((feature) => feature.label)).toEqual(["Auto-accept"]);
+  } finally {
+    await client.shutdown();
+  }
+});
+
+test("keeps native Paseo tools available when an external server is configured", async () => {
+  const { OpenCodeRuntimeClient } = await import("./runtime-client.js");
+  const { createTestLogger } = await import("../../../../test-utils/test-logger.js");
+  const { OpenCodeBridge } = await import("./bridge.js");
+  const bridge = new OpenCodeBridge({ paseoHome: "/tmp", logger: createTestLogger() });
+  const external = new OpenCodeRuntimeClient(
+    createTestLogger(),
+    { env: { PASEO_OPENCODE_SERVER_URL: "http://127.0.0.1:4096" } },
+    { bridge },
+  );
+  const local = new OpenCodeRuntimeClient(createTestLogger(), undefined, { bridge });
+  try {
+    expect(external.capabilities.supportsNativePaseoTools).toBe(true);
+    expect(local.capabilities.supportsNativePaseoTools).toBe(true);
+  } finally {
+    await external.shutdown();
+    await local.shutdown();
+  }
+});

packages/server/src/server/agent/providers/opencode/runtime-client.ts

@@ -19,7 +19,9 @@ import {
 import { execCommand } from "../../../../utils/spawn.js";
 import { OpenCodeAgentClient } from "../opencode-agent.js";
 import type { OpenCodeV2AgentClient } from "./v2/agent.js";
+import { resolveExternalOpenCodeServer } from "./v2/external-server.js";
 import { withOpenCodeRuntimeNotice } from "./runtime-notice.js";
+import { selectOpenCodeService } from "./v2/service-selection.js";
 
 // Keep the minimum aligned with the SDK and binary exercised by CI.
 const MINIMUM_V2: readonly [number, number] = [0, 10];
@@ -67,8 +69,25 @@ export class OpenCodeRuntimeClient implements AgentClient {
     this.resolveCreateConfig = this.legacy.resolveCreateConfig;
     this.isCreateConfigUnattended = this.legacy.isCreateConfigUnattended;
   }
+  private selectService() {
+    return selectOpenCodeService({
+      explicit: resolveExternalOpenCodeServer({ ...globalThis.process.env, ...this.settings?.env }),
+      env: this.settings?.env,
+    });
+  }
   private client(): Promise<OpenCodeAgentClient | OpenCodeV2AgentClient> {
     this.selected ??= (async () => {
+      const selection = await this.selectService();
+      if (selection.kind !== "owned") {
+        const { OpenCodeV2AgentClient } = await import("./v2/agent.js");
+        return new OpenCodeV2AgentClient({
+          logger: this.logger,
+          settings: this.settings,
+          managedProcesses: this.options.managedProcesses,
+          bridge: this.options.bridge,
+          selection,
+        });
+      }
       let output: string;
       try {
         const launch = await resolveProviderLaunch({
@@ -97,6 +116,7 @@ export class OpenCodeRuntimeClient implements AgentClient {
         settings: this.settings,
         managedProcesses: this.options.managedProcesses,
         bridge: this.options.bridge,
+        selection,
       });
     })().catch((error: unknown) => {
       // A failed probe must not poison refresh after the user updates the binary.
@@ -106,9 +126,14 @@ export class OpenCodeRuntimeClient implements AgentClient {
     return this.selected;
   }
   async isAvailable() {
+    const selection = await this.selectService();
+    if (selection.kind !== "owned") return true;
     return this.legacy.isAvailable();
   }
   async getDiagnostic() {
+    const selection = await this.selectService();
+    if (selection.kind !== "owned")
+      return { diagnostic: `OpenCode server: ${selection.server.url}` };
     return this.legacy.getDiagnostic();
   }
   async createSession(