diff --git a/devlog/_plan/260912_remote_workspace_carry/030_integration.md b/devlog/_plan/260912_remote_workspace_carry/030_integration.md
index 5c126f5987..4cf079534d 100644
--- a/devlog/_plan/260912_remote_workspace_carry/030_integration.md
+++ b/devlog/_plan/260912_remote_workspace_carry/030_integration.md
@@ -67,3 +67,23 @@ Local tests/build/typecheck/install NOT RUN by user instruction. Text comparison
 NEW src/remote-control/workspace-activation.ts exports a side-effect-free guard requiring runtimeRole=hub AND process.env.OCX_REMOTE_WORKSPACE_ENABLED === "1". This guard imports only the config type. Pair and agent branches call it before dynamic import; disabled requests return 404. Management namespace returns a disabled status before importing runtime. Shutdown uses already retained workspace references or initialized-only lazy import only when explicitly enabled; a disabled Hub never creates identity or probes model CLIs. CLI pairing remains explicit Executor-local authorization and never modifies server environment. Document the opt-in variable and require an explicit environment choice to enable the feature. Test disabled Hub, non-Hub with flag, and enabled Hub, with no ambient inheritance in fixtures.
 
 Existing-file conflicts observed by git apply --check: management-api.ts, management/context.ts and ws-bridge.ts. Port the namespace-dispatch addition into current management handler, append only type/dependency seam fields after current imports, and extend current WebSocket discriminator/handlers without replacing newer fields. The check was text applicability only, not a product test.
+
+## Phase-3 revalidation
+
+Previous D: runtime source cycle closed at a3182185f0 after corrected whitespace receipt. Final executable/native proof remains open; Windows commands unsupported. Continue integration from that exact parent. Carry current React resource/Select/Notice/icon conventions with no dependency additions. All locales inherit original translations with the unavailable-state opt-in message added consistently.
+
+Server adaptation: preserve current quota-reset and Grok coupon lazy dispatch. Add remote namespace handler before normal configuration routes. It answers disabled GET status with available:false and empty collections before loading workspace runtime; mutations when disabled refuse. Pair/agent paths require explicit guard before lazy imports and existing Origin/device-token validation. WebSocket data stores only structural receive/open/close callbacks; no concrete Hub class imports in ws-bridge. Upgrade closure owns hub/device association and close cleanup. Management dependency seams use structural Pick projections of only public Hub/session operations; all are import type and erased at runtime. Runtime modules use narrow config imports from phase 2, eliminating the prior broad runtime cycle.
+
+Shutdown: a promise-local initialized workspace module reference is set only on actual workspace route activation; shutdown calls initialized service getters only when that reference exists. It never dynamically imports remote runtime merely because runtimeRole is hub. Management-only activation also needs lifecycle-owned shutdown registration or a retained optional shutdown callback; resolve before B and test both paths.
+
+NEW tests/clients/remote-workspace-activation.test.ts covers hub+flag guard, disabled management status without store writes and unauthorized principal refusal before dependency construction. Existing server tests get explicit isolated flag setup/restore; no real devices. CLI capabilities list pair/agent/status, no Hub-status automation introduced. Regenerate skills/ocx reference surface through its existing generator (documentation only). Docs state OCX_REMOTE_WORKSPACE_ENABLED=1 opt-in, default read-only sessions, Linux conditional exec and both desktop native helpers refusing commands.
+
+Rendering: this worktree has no node_modules or gui/node_modules. Do not install or run a local build. Prefer final hosted package artifacts for a local static render with synthetic API responses; if no artifact exists, retain rendering as unmet acceptance and attach no historical screenshot as current evidence.
+
+### Awaited per-server cleanup decision
+
+The existing optional-shutdown registry is synchronous best-effort and cannot prove awaited Remote Workspace shutdown. Reuse server.stop's existing runListenerShutdown array instead. Add a per-server retained shutdown callback and a ManagementApiDeps onRemoteWorkspaceShutdown callback setter. Workspace management resolves its already-loaded services then registers an initialized-only cleanup closure through that setter; pair/agent loader registers the same kind of closure. server.stop calls the retained callback if present. No callback means no remote import/work. Keep registration idempotent and closure references scoped to the current config/server; tests cover management-only initialization and explicit stop. Do not change the global optional-shutdown API.
+
+In-flight initialization refinement: management checks per-server stopping before and after module import, creates Hub/session services synchronously in one turn, then registers initialized-only teardown. Pair/upgrade paths check stopping after lazy load. SessionService rejects create/resume after shutdown even when an availability promise completes later; a regression holds availability across shutdown. This prevents request initialization from creating resources after stop.
+
+Source-audit follow-up: pending creation promises and late handle cleanup are owned by shutdown, which settles all session cleanups before propagating failure. Pair-body completion rechecks stop admission. UI derives enrollment commands from the actual shared Hub origin, keeps drafts per session, preserves newer input on failure, shares submission eligibility between keyboard/button, warns on stale snapshots, and permits Stop during pairing. Controlled runtime/body/draft/Stop regressions accompany these adaptations; execution remains hosted-only.
diff --git a/devlog/_plan/260912_remote_workspace_carry/041_resume_ci_repair.md b/devlog/_plan/260912_remote_workspace_carry/041_resume_ci_repair.md
new file mode 100644
index 0000000000..0b8bcdec90
--- /dev/null
+++ b/devlog/_plan/260912_remote_workspace_carry/041_resume_ci_repair.md
@@ -0,0 +1,23 @@
+# Resumed final-tip verification
+
+The integration branch was fast-forwarded from 5c462fec1a to existing remote head 4ad1d1ce54 without rewriting the six intervening commits. PRs #4344, #4362 and #4372 remain open. CI run 34683454076 at 4ad1d1ce54359ee25fbb078344a22bdb16f7e304 failed; cancelled and skipped jobs are not passing evidence.
+
+## Scoped repair
+
+MODIFY tests/clients/remote-workspace-activation.test.ts: provide the HTTP Host precondition that managementRequestOrigin requires. Preserve 200/404 expectations and assert the admin-token denial message so a generic origin failure cannot satisfy the consent regression.
+
+MODIFY tests/clients/remote-workspace-sessions.test.ts: observe pending rejection using native Promise settlement, release the held start/availability gate, then assert rejection. Keep late runtime cleanup, one-stop/one-close checks, terminal failure state, and assert zero model prompts. Production cleanup code is unchanged. The source dependency order is verified; Bun matcher scheduling remains a hypothesis until repaired-head hosted execution confirms it.
+
+The host goal is observed blocked and the native cycle remains C; no direct goal/FSM edits or reset were performed. This repair continues the incomplete integration Check under explicit resume authorization. It is not claimed as an additional completed cycle. Local suites/build/typecheck/install are NOT RUN. Independent inherited-model review and final cumulative-tip hosted CI remain required.
+
+## Render provenance
+
+Dashboard artifact 10294424393 from run 34683454076 records merge-ref commit 5270d422166eb56692d1fde1513d5ff4f40533d4 and GUI tree 69b1bce039ee18cecea2586bc484c2afe0523a13, equal to candidate 4ad1d1ce54:gui. It is rendered with synthetic example state on a loopback static server; mutations are disabled. This proves the captured layout only, not real pairing or runtime execution.
+
+Observed screenshots: assets/041_desktop_read_only.png and assets/042_desktop_files_only.png at 1440x913 CSS pixels. The actual access picker changes from Read only to Edit files only and displays the command-unavailable notice. No live enrollment or model operation was invoked. A requested390px native-window resize stopped at500px; that is not390px proof, and no narrower layout claim is made. The installed browser CLI does not expose the documented script command; no driver was installed to work around it.
+
+## Windows subprocess fixtures
+
+Run34693137770 at d1a922ae reports three remote-owned fixture failures on Windows: two native response cases cannot execute a POSIX shebang file, and the cwd case times out while starting PowerShell. The intended contracts are bounded stdin/response decoding and real child cwd; neither requires a shell. Replace only test subprocess fixtures with the exact current Bun executable, preserve helper-path checks, timeout/output bounds and success/error assertions. Native Windows command support remains disabled. Local suites remain NOT RUN; independent source review and repaired-head hosted proof are required.
+
+The Windows native fixture keeps descriptor keys separate from its injected spawn function, verifies all pipe options before forwarding them unchanged, and never executes authority from the input JSON. Cwd checks compare decoded stdout with the canonical executor directory and exclude the canonical coordinator directory. An exact exit-code/empty-stderr assertion accompanies the unchanged deadline. At predecessor d1a922ae, hosted Windows2 job103552067478 passed the corrected disabled management status case; that narrow result is not an all-suite pass.
diff --git a/devlog/_plan/260912_remote_workspace_carry/assets/041_desktop_read_only.png b/devlog/_plan/260912_remote_workspace_carry/assets/041_desktop_read_only.png
new file mode 100644
index 0000000000..9075e975be
Binary files /dev/null and b/devlog/_plan/260912_remote_workspace_carry/assets/041_desktop_read_only.png differ
diff --git a/devlog/_plan/260912_remote_workspace_carry/assets/042_desktop_files_only.png b/devlog/_plan/260912_remote_workspace_carry/assets/042_desktop_files_only.png
new file mode 100644
index 0000000000..c99e88e29f
Binary files /dev/null and b/devlog/_plan/260912_remote_workspace_carry/assets/042_desktop_files_only.png differ
diff --git a/docs-site/astro.config.mjs b/docs-site/astro.config.mjs
index b25586f7a6..b76a01cdd5 100644
--- a/docs-site/astro.config.mjs
+++ b/docs-site/astro.config.mjs
@@ -86,6 +86,7 @@ export default defineConfig({
           translations: { fr: "Guides", ko: "가이드", "zh-CN": "指南", "zh-TW": "指南", ru: "Руководства", ja: "ガイド", tr: "Kılavuzlar" },
           items: [
             { label: "Remote Hub Deployment", translations: { fr: "Déploiement Remote Hub", ko: "Remote Hub 배포", "zh-CN": "Remote Hub 部署", "zh-TW": "Remote Hub 部署", ru: "Развёртывание Remote Hub", ja: "Remote Hub のデプロイ", tr: "Remote Hub Dağıtımı" }, slug: "guides/remote-hub" },
+            { label: "Remote Workspace", translations: { fr: "Espace de travail distant", ko: "원격 워크스페이스", "zh-CN": "远程工作区", "zh-TW": "遠端工作區", ru: "Удалённая рабочая область", ja: "リモートワークスペース", tr: "Uzak Çalışma Alanı" }, slug: "guides/remote-workspace" },
             { label: "Providers", translations: { fr: "Fournisseurs", ko: "프로바이더", "zh-CN": "提供商", "zh-TW": "供應商", ru: "Провайдеры", ja: "プロバイダー", tr: "Sağlayıcılar" }, slug: "guides/providers" },
             { label: "Factory Droid Bridge", translations: { fr: "Pont Factory Droid", ko: "Factory Droid 브리지" }, slug: "guides/factory-droid" },
             { label: "Cursor Private Inference", translations: { ko: "Cursor Private Inference" }, slug: "guides/cursor-private-inference" },
diff --git a/docs-site/src/content/docs/guides/remote-hub.md b/docs-site/src/content/docs/guides/remote-hub.md
index 0db5e7bcd5..bedd3e73a4 100644
--- a/docs-site/src/content/docs/guides/remote-hub.md
+++ b/docs-site/src/content/docs/guides/remote-hub.md
@@ -13,7 +13,9 @@ the hub's own processes dial `127.0.0.1:<the same port>` with no credential, thr
 companion listener. Start from [the recipe below](#linux-systemd-or-macos-launchd), then hand a
 second machine a ready-made command with [`ocx hub invite`](#inviting-another-machine).
 
-The management ingress never serves `/v1/*`, `/healthz`, `/readyz`, or WebSockets. Do not publish its
+The management ingress never serves `/v1/*`, `/healthz`, or `/readyz`. When explicitly enabled,
+Remote Workspace admits only its paired bearer-authenticated agent WebSocket and one-time pairing
+exchange; see [Remote Workspace](/guides/remote-workspace/). Do not publish its
 port directly, do not add a cloud-firewall rule for it, and do not use Tailscale Funnel. Funnel is a
 public-internet surface and is outside this deployment model.
 
diff --git a/docs-site/src/content/docs/guides/remote-workspace.md b/docs-site/src/content/docs/guides/remote-workspace.md
new file mode 100644
index 0000000000..4d31a6dee0
--- /dev/null
+++ b/docs-site/src/content/docs/guides/remote-workspace.md
@@ -0,0 +1,195 @@
+---
+title: Remote Workspace
+description: Keep Codex, Claude Code, Pi, and their logins on one OCX Hub while OCX-only computers provide the workspace and build environment.
+---
+
+Remote Workspace lets one OpenCodex Hub run your coding agents while another computer supplies the
+project files, commands, tests, and build compute. A phone or third computer can control the session
+through the Hub dashboard.
+
+```text
+Phone browser -> Computer 1 OCX Hub -> encrypted channel -> Computer 2 OCX Executor
+                 Codex / Claude / Pi                       project and commands
+                 logins and sessions                      no coding CLI login
+```
+
+The Executor needs OpenCodex only. It does not need Codex, Claude Code, Pi, a ChatGPT login, or a
+provider API key. It opens an outbound WebSocket to the Hub, so the Executor needs no public port or
+router port-forward.
+
+:::caution[Experimental foundation]
+Remote Workspace is opt-in and not a production rollout. Linux offers file tools and conditional
+bubblewrap command execution. Windows and macOS offer file tools only: their official native
+helpers reject probe and command requests. Windows commands remain unsupported until a verified
+lifecycle owner can retain cleanup authority through cancellation. Missing command support never
+falls back to executing on the Hub.
+:::
+
+## Set up the Hub
+
+Computer 1 owns every coding-agent login and model session. Install and log in to whichever agents
+you want to use there, then run OpenCodex as a Hub:
+
+```bash
+ocx config set runtimeRole hub
+OCX_REMOTE_WORKSPACE_ENABLED=1 ocx start
+ocx gui
+```
+
+Set `OCX_REMOTE_WORKSPACE_ENABLED=1` on the Hub process itself; setting it only for a dashboard
+command does not enable an already-running service. A Hub with no explicit opt-in returns disabled
+status without creating workspace keys or probing coding-agent runtimes.
+
+Use an authenticated HTTPS deployment when opening the dashboard from a phone or another computer.
+See [Remote Hub Deployment](/guides/remote-hub/) for the supported management-ingress and Tailscale
+pattern. Do not publish an unauthenticated local dashboard port.
+
+Codex Remote Workspace uses current App Server permission profiles. If the Hub's selected Codex
+configuration still sets legacy `sandbox_mode` or `sandbox_workspace_write`, the dashboard reports
+Codex as unavailable instead of starting with a weaker boundary. Migrate that Codex profile before
+using the feature; do not configure both the legacy sandbox and a permission profile.
+
+## Pair an Executor
+
+1. Open **Remote Workspace** in the Hub dashboard.
+2. Select **Create pairing code**.
+3. On Computer 2, change into the project directory you want to expose.
+4. Copy the generated **Linux / macOS terminal** or **Windows PowerShell** command for that computer.
+   It pairs the current directory and keeps
+   `ocx remote-workspace agent` connected in that terminal.
+
+The equivalent manual flow is:
+
+```bash
+cd /path/to/project
+printf '%s\n' 'ONE-TIME-CODE' | ocx remote-workspace pair 'https://your-hub.example' \
+  --pairing-code-stdin --root "$PWD"
+ocx remote-workspace agent
+```
+
+On Windows PowerShell, use the command shown in the dashboard. The equivalent manual form is:
+
+```powershell
+$pairingCode = 'ONE-TIME-CODE'
+$pairingCode | ocx remote-workspace pair 'https://your-hub.example' `
+  --pairing-code-stdin --root (Get-Location).Path
+if ($LASTEXITCODE -eq 0) { ocx remote-workspace agent }
+```
+
+The current OCX Bun executable is added as one read-only file to the Linux sandbox automatically. If
+the project needs a user-installed toolchain outside the system paths, pair it explicitly without
+exposing the rest of the home directory:
+
+```bash
+printf '%s\n' 'ONE-TIME-CODE' | ocx remote-workspace pair 'https://your-hub.example' \
+  --pairing-code-stdin --root "$PWD" \
+  --toolchain-root "$HOME/.nvm/versions/node/v24/bin"
+```
+
+The native helper source is packaged for review. Building it does not enable Windows or macOS
+commands in this carry. `--executor-helper` remains a reviewed-helper selector; binary existence
+or a configured path does not prove command support.
+
+The one-time code is read from standard input, not command-line arguments. Pairing creates a local
+device signing key and a device-scoped bearer. The Hub stores only its hash and never receives the
+real Executor path. Stop the foreground agent with Ctrl+C; running it again reconnects the same
+device.
+
+Check local enrollment without printing secrets:
+
+```bash
+ocx remote-workspace status
+```
+
+## Start a remote coding session
+
+In the dashboard choose:
+
+1. the online computer;
+2. one locally approved workspace folder;
+3. Codex, Claude Code, or Pi from the Hub; and
+4. an access mode.
+
+**Read only** is the default and exposes directory listing and file reading. The write option is
+shown as **Edit files and run commands** only when that Executor passed a command-sandbox probe;
+otherwise it is shown as **Edit files only**. The dashboard shows two separate locations so it is
+clear that the model and login remain on the Hub while workspace operations run on the selected
+computer.
+
+Send prompts from the Hub dashboard on Computer 1, Computer 3, or a phone. The session cannot switch
+to another computer or folder silently. If the Executor disconnects, the session enters
+**Executor offline** and never falls back to the Hub's filesystem.
+
+Prompt submission acknowledges acceptance immediately; the dashboard polls the session for progress and completion. If the acknowledgement is lost, the draft remains visible with an unknown-submission notice. Check session progress before sending it again; the dashboard never retries a prompt automatically.
+
+**Stop** remains available while a prompt is running. It interrupts the Hub coding-agent turn,
+cancels an active Executor command, and prevents a late response from reopening the stopped
+session.
+
+## Restart and reconnect behavior
+
+The Hub persists bounded session metadata and a small recent event snapshot. After a Hub restart,
+an unfinished session waits for its original Executor. Once that device reconnects, the next prompt
+resumes the original Codex thread, Claude Code session, or Pi session ID.
+
+Claude Code creates its durable history on the first completed prompt. If the Hub stops before a
+new Claude session has completed any prompt, there is no conversation to resume; start a new
+session instead.
+
+A changed capability manifest does not silently weaken an existing session. Start a new session if
+the Executor loses command containment or its available tools change. Revoking a computer closes its
+socket and stops sessions bound to it.
+
+## Security boundaries
+
+- Provider credentials and coding-agent history remain on the Hub.
+- Executor private keys, device bearer, and real root paths remain in its owner-only OCX state.
+- Pairing-code failures are limited per kernel-observed peer on every listener. Ten failed codes in
+  ten minutes return a generic `429` with `Retry-After`; the Hub retains only bounded, expiring
+  hashes of those source identities. Tailscale Serve users share the management listener's loopback
+  bucket because a direct local caller could forge its identity header.
+- Each work session uses an Ed25519-signed ephemeral P-256 ECDH handshake and ordered
+  AES-256-GCM messages.
+- A socket is not shown as online until both sides agree on its current capability manifest.
+- Reconnection may remove a capability when its local sandbox is unavailable, but never adds a
+  capability outside the grant recorded at pairing.
+- Every request is bound to one model thread, device, root, access mode, and capability set.
+- Paths are relative, canonicalized, bounded, and rejected on symlink, junction, or parent-directory
+  escape. Windows device names, alternate data streams, and trailing-dot/space aliases are denied.
+- Executor operations are serialized, opened file identities are rechecked, and write hashes are
+  checked again immediately before atomic replacement. Replacing an approved root requires pairing
+  it again, and toolchain roots are revalidated before each command.
+- File reads/writes reject hard-linked files. Before command execution, OCX scans at most 250,000
+  workspace entries and disables the command path if any non-directory entry has multiple links;
+  path sandboxes cannot prove whether the other name for that inode is outside the approved root.
+- Linux commands run through bubblewrap with one writable workspace, cleared environment, private
+  process namespaces, the current OCX Bun executable as one read-only file, bounded output
+  and timeout, and network disabled by default. Dedicated confinement tests require an explicitly
+  configured hosted environment; a green generic suite does not prove they ran.
+- macOS advertises file tools only. A process group cannot contain a descendant after it calls
+  `setsid()`, and importing a broad Apple Seatbelt system profile merely to start a command would
+  expose unrelated host-service authority. The native helper therefore rejects both its probe and
+  direct command requests until OCX has a narrow, revocable descendant-containment owner.
+- Windows and macOS native command requests fail closed. Their direct-helper refusal tests must be
+  distinguished from functioning command-confinement evidence; Windows command acceptance is open.
+- The pinned native helper must be outside every approved writable workspace. OCX checks this both
+  before advertising command support and immediately before each command, so workspace code cannot
+  replace the binary that enforces its next sandbox.
+- Stopping a session cancels an active Executor command and cleans up the Hub model process and
+  loopback tool bridge. Windows stops the owned npm-wrapper process tree rather than leaving its
+  Node child behind; Linux and macOS force-stop a CLI only if it ignores the graceful stop window.
+
+The Hub intentionally sees prompts and model output because it runs the coding agent. End-to-end
+encryption protects Executor RPC payloads. The paired Hub is trusted to select approved roots over
+authenticated WSS; it is not blind to its own model conversation.
+
+## Current scope
+
+Remote Workspace does not copy or synchronize credentials to other computers. It is separate from
+Remote Hub provider routing and from any future hosted compute or Super Sync product. A production
+release still requires signed Windows helper packaging, native CI proof on the exact binaries,
+independent maintainer review, and a real three-computer acceptance run.
+
+## Prompt acceptance API
+
+`POST /api/remote-workspace/sessions/:id/prompt` returns HTTP 202 with the accepted session snapshot. Its session ID and monotonic event sequence identify the acceptance snapshot; 202 does not mean that the model turn completed. Poll `GET /api/remote-workspace/sessions` for later events and terminal status. Reconnect and runtime resume remain busy while that turn is active. A lost acknowledgement leaves acceptance unknown, so clients must poll before choosing whether to submit again.
diff --git a/docs-site/src/content/docs/reference/cli.md b/docs-site/src/content/docs/reference/cli.md
index e39d0cc018..d91e6c1865 100644
--- a/docs-site/src/content/docs/reference/cli.md
+++ b/docs-site/src/content/docs/reference/cli.md
@@ -18,6 +18,19 @@ opencodex state.
 
 `ocx alias list [--json]` shows effective user and built-in aliases. Use `ocx alias set <provider>[/<native-model-id>] <alias>` and `ocx alias rm <provider>[/<native-model-id>]` to edit them. Native model ids may contain additional slashes because the selector splits only at the first slash. Enable shipped defaults with `ocx alias defaults on|off [--provider <name>]`.
 
+### `ocx remote-workspace`
+
+`ocx remote-workspace pair <hub-url> --pairing-code-stdin --root <absolute-path>` enrolls the local
+computer as an OCX-only Executor. Repeat `--root` to approve more folders and use `--name` to
+override the hostname. Repeat `--toolchain-root <absolute-directory>` to expose a user-installed
+Node, Rust, Go, or other toolchain directory read-only inside the command sandbox. On macOS and
+Windows private-dogfood builds, `bun run build:remote-workspace-helper` creates the Rust helper that
+the pair command discovers automatically; `--executor-helper <absolute-file>` selects another
+explicitly reviewed build and pins its digest in local Executor state.
+`ocx remote-workspace agent` maintains the outbound encrypted connection;
+`ocx remote-workspace status [--json]` reports the Hub, device, roots, and advertised capabilities
+without printing its bearer or private key. See [Remote Workspace](/guides/remote-workspace/).
+
 - [Lifecycle](/reference/cli/lifecycle/) — setup, proxy and service lifecycle, health, diagnostics,
   catalog sync, the dashboard, and updates.
 - [Providers, accounts, and models](/reference/cli/providers-accounts/) — provider configuration,
diff --git a/docs-site/src/content/docs/reference/management-api.md b/docs-site/src/content/docs/reference/management-api.md
index cd8b2450c2..75a0f89fb2 100644
--- a/docs-site/src/content/docs/reference/management-api.md
+++ b/docs-site/src/content/docs/reference/management-api.md
@@ -145,6 +145,34 @@ should use the dedicated paths above so an older proxy cannot ignore a profile s
 See [Aside profile controls](/guides/integrations/#aside-profile-controls) for CLI commands and
 the proxy upgrade, restart, and retry sequence.
 
+### Remote Workspace
+
+Requires Hub mode and `OCX_REMOTE_WORKSPACE_ENABLED=1` on the Hub process. Disabled status is
+readable; mutations refuse without initializing workspace services.
+
+| Method and path | Purpose | Notable errors |
+| --- | --- | --- |
+| `GET /api/remote-workspace` | Read paired computers, current capabilities, Hub runtimes, and session snapshots | Disabled status when Hub role or explicit opt-in is absent |
+| `POST /api/remote-workspace/pairing` | Create a ten-minute one-use Executor enrollment code | GUI session only; 429 pairing capacity |
+| `GET /api/remote-workspace/runtimes` | Read Codex, Claude Code, and Pi availability on the Hub | — |
+| `GET, POST /api/remote-workspace/sessions` | List sessions or start one bound to a device, root, runtime, and access mode | POST is GUI session only; 409 offline/unavailable/invalid target |
+| `POST /api/remote-workspace/sessions/{id}/prompt` | Continue the bound model session | GUI session only; 409 active turn, offline Executor, or resume failure |
+| `DELETE /api/remote-workspace/sessions/{id}` | Stop the model runtime and encrypted Executor session | GUI session only; 404 unknown session |
+| `DELETE /api/remote-workspace/devices/{id}` | Revoke one computer and stop its sessions | GUI session only; 404 unknown device |
+
+Executor enrollment exchanges a one-use code at `POST /remote-workspace/pair` and then opens
+`/remote-workspace/agent` as a bearer-authenticated outbound WebSocket. Those two machine endpoints
+are not general management API authority. The bearer is device-scoped, and each work session adds a
+signed E2EE handshake. Ten failed pairing codes from one kernel-observed peer return `429` with
+`Retry-After` for the remainder of the fixed ten-minute window. Tailscale Serve clients share the
+management listener's loopback peer bucket; the identity header is not used for throttling because
+a direct local process could forge it. See [Remote Workspace](/guides/remote-workspace/) for the
+end-user flow and trust boundaries.
+
+Session snapshots include `resumable`. It becomes true only after the selected coding-agent runtime
+has durable history; notably, a new Claude Code session remains false until its first prompt
+completes.
+
 ### Combos
 
 | Method and path | Purpose | Notable errors |
diff --git a/gui/src/App.tsx b/gui/src/App.tsx
index 91890ce664..b5e60c87db 100644
--- a/gui/src/App.tsx
+++ b/gui/src/App.tsx
@@ -10,6 +10,7 @@ import Storage from "./pages/Storage";
 import CodexSet from "./pages/CodexSet";
 import Integrations from "./pages/Integrations";
 import Startup from "./pages/Startup";
+import RemoteWorkspace from "./pages/RemoteWorkspace";
 import ErrorBoundary from "./components/ErrorBoundary";
 import { SidebarGithubRow } from "./components/sidebar-github-row";
 import { IconGrid, IconServer, IconBoxes, IconBot, IconList, IconActivity, IconHardDrive, IconCodex, IconMenu, IconSun, IconMoon, IconMonitor, IconGlobe, IconPower, IconX, IconRefresh} from "./icons";
@@ -35,6 +36,7 @@ const PAGE_TKEY: Record<Page, TKey> = {
   logs: "nav.logs",
   usage: "nav.usage",
   storage: "nav.storage",
+  remote: "nav.remote",
   "codex-set": "nav.codexSet",
   integrations: "nav.integrations",
 };
@@ -68,6 +70,7 @@ const NAV: NavEntry[] = [
   { id: "logs", tkey: "nav.logs", Icon: IconList },
   { id: "usage", tkey: "nav.usage", Icon: IconActivity },
   { id: "storage", tkey: "nav.storage", Icon: IconHardDrive },
+  { id: "remote", tkey: "nav.remote", Icon: IconMonitor },
   { id: "integrations", tkey: "nav.integrations", Icon: IconGlobe },
 ];
 
@@ -432,6 +435,7 @@ export default function App() {
                 {page === "logs" && <Logs apiBase={sharedBase} />}
                 {page === "usage" && <Usage apiBase={sharedBase} connected={targets.connected} apiKeyId={targets.apiKeyId} />}
                 {page === "storage" && <Storage apiBase={sharedBase} />}
+                {page === "remote" && <RemoteWorkspace apiBase={sharedBase} hubOrigin={targets.shared.serverOrigin} />}
                 {page === "codex-set" && <CodexSet apiBase={sharedBase} />}
                 {page === "integrations" && <Integrations apiBase={sharedBase} machineApiBase={machineBase} connected={targets.connected} />}
               </>
diff --git a/gui/src/app-routing.ts b/gui/src/app-routing.ts
index e2184af3d2..9dbf4d28bc 100644
--- a/gui/src/app-routing.ts
+++ b/gui/src/app-routing.ts
@@ -11,6 +11,7 @@ export type Page =
   | "logs"
   | "usage"
   | "storage"
+  | "remote"
   | "codex-set"
   | "integrations";
 
@@ -23,6 +24,7 @@ export const VALID_PAGES = new Set<Page>([
   "logs",
   "usage",
   "storage",
+  "remote",
   "codex-set",
   "integrations",
 ]);
diff --git a/gui/src/i18n/de.ts b/gui/src/i18n/de.ts
index 68feff3023..c184db815f 100644
--- a/gui/src/i18n/de.ts
+++ b/gui/src/i18n/de.ts
@@ -2719,4 +2719,65 @@ export const de: Record<TKey, string> = {
   "models.pickerOrder.saveDraft": "Entwurf speichern",
   "models.pickerOrder.reloadDraft": "Neu laden und Entwurf verwerfen",
   "models.pickerOrder.catalogRequired": "Modellidentitäten fehlen oder sind mehrdeutig. Laden Sie die Modellseite neu, um den Katalog vor der Bearbeitung zu aktualisieren.",
+  "nav.remote": "Remote-Arbeitsbereich",
+  "remote.title": "Remote-Arbeitsbereich",
+  "remote.subtitle": "Codex, Claude Code oder Pi laufen auf diesem Hub; Dateien, Befehle, Tests und Builds bleiben auf dem ausgewählten Computer.",
+  "remote.loading": "Remote-Arbeitsbereich wird geladen…",
+  "remote.loadFailed": "Remote-Arbeitsbereich konnte nicht geladen werden.",
+  "remote.hubRequired": "Starten Sie den Hub im Hub-Modus mit OCX_REMOTE_WORKSPACE_ENABLED=1, um Remote Workspace zu aktivieren.",
+  "remote.refresh": "Aktualisieren",
+  "remote.addComputer": "Computer hinzufügen",
+  "remote.addComputerHint": "Gib lokal Ordner frei und halte den reinen OCX-Executor mit diesem Hub verbunden.",
+  "remote.createPairing": "Kopplungscode erstellen",
+  "remote.pairingCode": "Einmaliger Kopplungscode",
+  "remote.pairingExpires": "Läuft um {time} ab",
+  "remote.pairingCommand": "Auf dem hinzuzufügenden Computer ausführen",
+  "remote.pairingCommandPosix": "Linux- / macOS-Terminal",
+  "remote.pairingCommandWindows": "Windows PowerShell",
+  "remote.copyCommand": "Befehl kopieren",
+  "remote.copied": "Kopiert",
+  "remote.devices": "Computer",
+  "remote.noDevices": "Noch keine Computer gekoppelt.",
+  "remote.online": "Online",
+  "remote.offline": "Offline",
+  "remote.revoke": "Computer widerrufen",
+  "remote.revokeConfirm": "{name} widerrufen? Aktive Sitzungen auf diesem Computer werden beendet.",
+  "remote.newSession": "Neue Remote-Sitzung",
+  "remote.device": "Computer",
+  "remote.folder": "Arbeitsordner",
+  "remote.runtime": "Coding-Agent",
+  "remote.access": "Workspace-Zugriff",
+  "remote.access.readOnly": "Nur lesen",
+  "remote.access.workspace": "Dateien bearbeiten und Befehle ausführen",
+  "remote.access.workspaceFilesOnly": "Nur Dateien bearbeiten",
+  "remote.unavailable": "Nicht verfügbar",
+  "remote.capability.full": "Dateien + isolierte Befehle",
+  "remote.capability.files": "Nur Dateiwerkzeuge",
+  "remote.runsOnHub": "Modell und Anmeldung bleiben auf diesem Hub",
+  "remote.runsReadOnly": "Dateien können auf diesem Computer nur gelesen werden",
+  "remote.runsFilesCommands": "Dateien, Builds und Befehle laufen hier",
+  "remote.runsFilesOnly": "Dateiwerkzeuge laufen hier; Befehls-Sandbox nicht verfügbar",
+  "remote.execUnavailable": "Dieser Computer kann Dateien bearbeiten, aber Builds und Terminalbefehle sind ohne unterstützte Betriebssystem-Sandbox deaktiviert.",
+  "remote.notResumable": "Diese Sitzung wurde beendet, bevor der Coding-Agent einen dauerhaften Verlauf erstellt hat. Starten Sie eine neue Remote-Sitzung.",
+  "remote.startSession": "Remote-Sitzung starten",
+  "remote.sessionStarted": "Remote-Sitzung ist bereit.",
+  "remote.sessions": "Sitzungen",
+  "remote.noSessions": "Wähle einen Online-Computer, Ordner und Coding-Agenten.",
+  "remote.events": "Aktivität der Remote-Sitzung",
+  "remote.noEvents": "Noch keine Aktivität.",
+  "remote.prompt": "Nachricht",
+  "remote.promptPlaceholder": "Bitte den Hub-Agenten, im ausgewählten Remote-Ordner zu arbeiten…",
+  "remote.send": "Senden",
+  "remote.stop": "Sitzung stoppen",
+  "remote.requestFailed": "Remote-Workspace-Anfrage fehlgeschlagen.",
+  "remote.submissionUnknown": "Der Übermittlungsstatus ist unbekannt. Prüfen Sie die Sitzung, bevor Sie erneut senden.",
+  "remote.status.starting": "Startet",
+  "remote.status.ready": "Bereit",
+  "remote.status.running": "Läuft",
+  "remote.status.waiting": "Executor offline",
+  "remote.status.failed": "Fehlgeschlagen",
+  "remote.status.stopped": "Gestoppt",
+  "remote.event.status": "Status",
+  "remote.event.tool": "Remote-Werkzeug",
+  "remote.event.error": "Fehler",
 };
diff --git a/gui/src/i18n/en.ts b/gui/src/i18n/en.ts
index 63f54b0c32..10eb37ce10 100644
--- a/gui/src/i18n/en.ts
+++ b/gui/src/i18n/en.ts
@@ -2753,6 +2753,67 @@ export const en = {
   "models.pickerOrder.saveDraft": "Save draft",
   "models.pickerOrder.reloadDraft": "Reload and discard draft",
   "models.pickerOrder.catalogRequired": "Model identities are missing or ambiguous. Reload the Models page to refresh its catalog before editing Custom.",
+  "nav.remote": "Remote Workspace",
+  "remote.title": "Remote Workspace",
+  "remote.subtitle": "Run Codex, Claude Code, or Pi from this Hub while files, commands, tests, and builds stay on the computer you select.",
+  "remote.loading": "Loading Remote Workspace…",
+  "remote.loadFailed": "Could not load Remote Workspace.",
+  "remote.hubRequired": "Use Hub mode and start the Hub with OCX_REMOTE_WORKSPACE_ENABLED=1 to enable Remote Workspace.",
+  "remote.refresh": "Refresh",
+  "remote.addComputer": "Add a computer",
+  "remote.addComputerHint": "Approve one or more folders locally, then keep the OCX-only executor connected to this Hub.",
+  "remote.createPairing": "Create pairing code",
+  "remote.pairingCode": "One-time pairing code",
+  "remote.pairingExpires": "Expires at {time}",
+  "remote.pairingCommand": "Run on the computer you are adding",
+  "remote.pairingCommandPosix": "Linux / macOS terminal",
+  "remote.pairingCommandWindows": "Windows PowerShell",
+  "remote.copyCommand": "Copy command",
+  "remote.copied": "Copied",
+  "remote.devices": "Computers",
+  "remote.noDevices": "No computers are paired yet.",
+  "remote.online": "Online",
+  "remote.offline": "Offline",
+  "remote.revoke": "Revoke computer",
+  "remote.revokeConfirm": "Revoke {name}? Active sessions on this computer will stop.",
+  "remote.newSession": "New remote session",
+  "remote.device": "Computer",
+  "remote.folder": "Workspace folder",
+  "remote.runtime": "Coding agent",
+  "remote.access": "Workspace access",
+  "remote.access.readOnly": "Read only",
+  "remote.access.workspace": "Edit files and run commands",
+  "remote.access.workspaceFilesOnly": "Edit files only",
+  "remote.unavailable": "Unavailable",
+  "remote.capability.full": "Files + sandboxed commands",
+  "remote.capability.files": "File tools only",
+  "remote.runsOnHub": "Model and login stay on this Hub",
+  "remote.runsReadOnly": "Files can only be read on this computer",
+  "remote.runsFilesCommands": "Files, builds, and commands run here",
+  "remote.runsFilesOnly": "File tools run here; command sandbox unavailable",
+  "remote.execUnavailable": "This computer can edit files, but builds and terminal commands are disabled because a supported OS sandbox is not available.",
+  "remote.notResumable": "This session stopped before the coding agent created durable history. Start a new remote session.",
+  "remote.startSession": "Start remote session",
+  "remote.sessionStarted": "Remote session is ready.",
+  "remote.sessions": "Sessions",
+  "remote.noSessions": "Choose an online computer, folder, and coding agent to start.",
+  "remote.events": "Remote session activity",
+  "remote.noEvents": "No activity yet.",
+  "remote.prompt": "Message",
+  "remote.promptPlaceholder": "Ask the Hub agent to work inside the selected remote folder…",
+  "remote.send": "Send",
+  "remote.stop": "Stop session",
+  "remote.requestFailed": "Remote Workspace request failed.",
+  "remote.submissionUnknown": "Submission status is unknown. Check the session before sending again.",
+  "remote.status.starting": "Starting",
+  "remote.status.ready": "Ready",
+  "remote.status.running": "Running",
+  "remote.status.waiting": "Executor offline",
+  "remote.status.failed": "Failed",
+  "remote.status.stopped": "Stopped",
+  "remote.event.status": "Status",
+  "remote.event.tool": "Remote tool",
+  "remote.event.error": "Error",
 } as const;
 
 export type TKey = keyof typeof en;
diff --git a/gui/src/i18n/fr.ts b/gui/src/i18n/fr.ts
index 5cf01bcba2..5fc0de4059 100644
--- a/gui/src/i18n/fr.ts
+++ b/gui/src/i18n/fr.ts
@@ -2707,4 +2707,65 @@ export const fr: Record<TKey, string> = {
   "models.pickerOrder.saveDraft": "Enregistrer le brouillon",
   "models.pickerOrder.reloadDraft": "Recharger et supprimer le brouillon",
   "models.pickerOrder.catalogRequired": "Les identités des modèles sont manquantes ou ambiguës. Rechargez la page Modèles pour actualiser le catalogue avant de personnaliser l’ordre.",
+  "nav.remote": "Espace distant",
+  "remote.title": "Espace de travail distant",
+  "remote.subtitle": "Codex, Claude Code ou Pi s'exécutent sur ce Hub tandis que fichiers, commandes, tests et builds restent sur l'ordinateur choisi.",
+  "remote.loading": "Chargement de l'espace distant…",
+  "remote.loadFailed": "Impossible de charger l'espace distant.",
+  "remote.hubRequired": "Démarrez le Hub en mode Hub avec OCX_REMOTE_WORKSPACE_ENABLED=1 pour activer Remote Workspace.",
+  "remote.refresh": "Actualiser",
+  "remote.addComputer": "Ajouter un ordinateur",
+  "remote.addComputerHint": "Autorisez localement un ou plusieurs dossiers, puis gardez l'exécuteur OCX connecté à ce Hub.",
+  "remote.createPairing": "Créer un code d'association",
+  "remote.pairingCode": "Code d'association à usage unique",
+  "remote.pairingExpires": "Expire à {time}",
+  "remote.pairingCommand": "À exécuter sur l'ordinateur à ajouter",
+  "remote.pairingCommandPosix": "Terminal Linux / macOS",
+  "remote.pairingCommandWindows": "Windows PowerShell",
+  "remote.copyCommand": "Copier la commande",
+  "remote.copied": "Copié",
+  "remote.devices": "Ordinateurs",
+  "remote.noDevices": "Aucun ordinateur associé.",
+  "remote.online": "En ligne",
+  "remote.offline": "Hors ligne",
+  "remote.revoke": "Révoquer l'ordinateur",
+  "remote.revokeConfirm": "Révoquer {name} ? Ses sessions actives seront arrêtées.",
+  "remote.newSession": "Nouvelle session distante",
+  "remote.device": "Ordinateur",
+  "remote.folder": "Dossier de travail",
+  "remote.runtime": "Agent de code",
+  "remote.access": "Accès à l’espace de travail",
+  "remote.access.readOnly": "Lecture seule",
+  "remote.access.workspace": "Modifier les fichiers et exécuter des commandes",
+  "remote.access.workspaceFilesOnly": "Modifier uniquement les fichiers",
+  "remote.unavailable": "Indisponible",
+  "remote.capability.full": "Fichiers + commandes isolées",
+  "remote.capability.files": "Outils de fichiers uniquement",
+  "remote.runsOnHub": "Le modèle et la connexion restent sur ce Hub",
+  "remote.runsReadOnly": "Les fichiers de cet ordinateur sont accessibles en lecture seule",
+  "remote.runsFilesCommands": "Les fichiers, builds et commandes s’exécutent ici",
+  "remote.runsFilesOnly": "Les outils de fichiers s’exécutent ici ; bac à sable indisponible",
+  "remote.execUnavailable": "Cet ordinateur peut modifier les fichiers, mais les builds et commandes de terminal sont désactivés faute de bac à sable système pris en charge.",
+  "remote.notResumable": "Cette session s’est arrêtée avant que l’agent de code ne crée un historique durable. Démarrez une nouvelle session distante.",
+  "remote.startSession": "Démarrer la session distante",
+  "remote.sessionStarted": "La session distante est prête.",
+  "remote.sessions": "Sessions",
+  "remote.noSessions": "Choisissez un ordinateur en ligne, un dossier et un agent de code.",
+  "remote.events": "Activité de la session distante",
+  "remote.noEvents": "Aucune activité pour le moment.",
+  "remote.prompt": "Message",
+  "remote.promptPlaceholder": "Demandez à l'agent du Hub de travailler dans le dossier distant choisi…",
+  "remote.send": "Envoyer",
+  "remote.stop": "Arrêter la session",
+  "remote.requestFailed": "La requête d'espace distant a échoué.",
+  "remote.submissionUnknown": "Le statut de l’envoi est inconnu. Vérifiez la session avant de renvoyer.",
+  "remote.status.starting": "Démarrage",
+  "remote.status.ready": "Prêt",
+  "remote.status.running": "En cours",
+  "remote.status.waiting": "Exécuteur hors ligne",
+  "remote.status.failed": "Échec",
+  "remote.status.stopped": "Arrêté",
+  "remote.event.status": "État",
+  "remote.event.tool": "Outil distant",
+  "remote.event.error": "Erreur",
 };
diff --git a/gui/src/i18n/ja.ts b/gui/src/i18n/ja.ts
index 5971eb8e3c..c39967ada5 100644
--- a/gui/src/i18n/ja.ts
+++ b/gui/src/i18n/ja.ts
@@ -2740,4 +2740,65 @@ export const ja: Record<TKey, string> = {
   "models.pickerOrder.saveDraft": "下書きを保存",
   "models.pickerOrder.reloadDraft": "下書きを破棄して再読み込み",
   "models.pickerOrder.catalogRequired": "モデルの識別情報が不足しているか曖昧です。モデルページを再読み込みしてカタログを更新してからカスタム順序を編集してください。",
+  "nav.remote": "リモートワークスペース",
+  "remote.title": "リモートワークスペース",
+  "remote.subtitle": "Codex、Claude Code、Pi はこの Hub で実行し、ファイル、コマンド、テスト、ビルドは選択したコンピューターで処理します。",
+  "remote.loading": "リモートワークスペースを読み込み中…",
+  "remote.loadFailed": "リモートワークスペースを読み込めませんでした。",
+  "remote.hubRequired": "Hub モードで OCX_REMOTE_WORKSPACE_ENABLED=1 を設定して Hub を起動すると、Remote Workspace を有効にできます。",
+  "remote.refresh": "更新",
+  "remote.addComputer": "コンピューターを追加",
+  "remote.addComputerHint": "ローカルでフォルダーを承認し、OCX 専用エグゼキューターをこの Hub に接続したままにします。",
+  "remote.createPairing": "ペアリングコードを作成",
+  "remote.pairingCode": "ワンタイムペアリングコード",
+  "remote.pairingExpires": "{time} に期限切れ",
+  "remote.pairingCommand": "追加するコンピューターで実行",
+  "remote.pairingCommandPosix": "Linux / macOS ターミナル",
+  "remote.pairingCommandWindows": "Windows PowerShell",
+  "remote.copyCommand": "コマンドをコピー",
+  "remote.copied": "コピー済み",
+  "remote.devices": "コンピューター",
+  "remote.noDevices": "ペアリング済みのコンピューターはありません。",
+  "remote.online": "オンライン",
+  "remote.offline": "オフライン",
+  "remote.revoke": "コンピューターを解除",
+  "remote.revokeConfirm": "{name} を解除しますか？このコンピューターの実行中セッションは停止します。",
+  "remote.newSession": "新しいリモートセッション",
+  "remote.device": "コンピューター",
+  "remote.folder": "ワークスペースフォルダー",
+  "remote.runtime": "コーディングエージェント",
+  "remote.access": "ワークスペース権限",
+  "remote.access.readOnly": "読み取り専用",
+  "remote.access.workspace": "ファイル編集とコマンド実行",
+  "remote.access.workspaceFilesOnly": "ファイル編集のみ",
+  "remote.unavailable": "利用不可",
+  "remote.capability.full": "ファイル + 分離されたコマンド",
+  "remote.capability.files": "ファイルツールのみ",
+  "remote.runsOnHub": "モデルとログインはこの Hub に保持",
+  "remote.runsReadOnly": "このコンピューターのファイルは読み取りのみ",
+  "remote.runsFilesCommands": "ファイル、ビルド、コマンドはここで実行",
+  "remote.runsFilesOnly": "ファイルツールのみここで実行、コマンド分離は未対応",
+  "remote.execUnavailable": "このコンピューターではファイル編集はできますが、対応する OS サンドボックスがないためビルドとターミナルコマンドは無効です。",
+  "remote.notResumable": "コーディングエージェントが永続的な履歴を作成する前にセッションが停止しました。新しいリモートセッションを開始してください。",
+  "remote.startSession": "リモートセッションを開始",
+  "remote.sessionStarted": "リモートセッションの準備ができました。",
+  "remote.sessions": "セッション",
+  "remote.noSessions": "オンラインのコンピューター、フォルダー、エージェントを選択してください。",
+  "remote.events": "リモートセッションのアクティビティ",
+  "remote.noEvents": "まだアクティビティはありません。",
+  "remote.prompt": "メッセージ",
+  "remote.promptPlaceholder": "選択したリモートフォルダーでの作業を Hub エージェントに依頼…",
+  "remote.send": "送信",
+  "remote.stop": "セッションを停止",
+  "remote.requestFailed": "リモートワークスペースの要求に失敗しました。",
+  "remote.submissionUnknown": "送信状況を確認できません。再送信する前にセッションを確認してください。",
+  "remote.status.starting": "開始中",
+  "remote.status.ready": "準備完了",
+  "remote.status.running": "実行中",
+  "remote.status.waiting": "エグゼキューターがオフライン",
+  "remote.status.failed": "失敗",
+  "remote.status.stopped": "停止済み",
+  "remote.event.status": "状態",
+  "remote.event.tool": "リモートツール",
+  "remote.event.error": "エラー",
 };
diff --git a/gui/src/i18n/ko.ts b/gui/src/i18n/ko.ts
index 8ae8f56b79..7d45690b78 100644
--- a/gui/src/i18n/ko.ts
+++ b/gui/src/i18n/ko.ts
@@ -2741,4 +2741,65 @@ export const ko: Record<TKey, string> = {
   "models.pickerOrder.saveDraft": "초안 저장",
   "models.pickerOrder.reloadDraft": "초안 버리고 다시 불러오기",
   "models.pickerOrder.catalogRequired": "모델 식별 정보가 없거나 모호합니다. 모델 페이지를 새로고침해 목록을 갱신한 뒤 사용자 지정 순서를 편집하세요.",
+  "nav.remote": "원격 워크스페이스",
+  "remote.title": "원격 워크스페이스",
+  "remote.subtitle": "Codex, Claude Code, Pi는 이 Hub에서 실행하고 파일·명령·테스트·빌드는 선택한 컴퓨터에서 처리합니다.",
+  "remote.loading": "원격 워크스페이스 불러오는 중…",
+  "remote.loadFailed": "원격 워크스페이스를 불러오지 못했습니다.",
+  "remote.hubRequired": "허브 모드에서 OCX_REMOTE_WORKSPACE_ENABLED=1로 허브를 시작하면 원격 작업 공간을 사용할 수 있습니다.",
+  "remote.refresh": "새로고침",
+  "remote.addComputer": "컴퓨터 추가",
+  "remote.addComputerHint": "추가할 컴퓨터에서 폴더를 승인하고 OCX 전용 실행기를 이 Hub에 계속 연결하세요.",
+  "remote.createPairing": "페어링 코드 만들기",
+  "remote.pairingCode": "일회용 페어링 코드",
+  "remote.pairingExpires": "{time}에 만료",
+  "remote.pairingCommand": "추가할 컴퓨터에서 실행",
+  "remote.pairingCommandPosix": "Linux / macOS 터미널",
+  "remote.pairingCommandWindows": "Windows PowerShell",
+  "remote.copyCommand": "명령어 복사",
+  "remote.copied": "복사됨",
+  "remote.devices": "컴퓨터",
+  "remote.noDevices": "아직 페어링된 컴퓨터가 없습니다.",
+  "remote.online": "온라인",
+  "remote.offline": "오프라인",
+  "remote.revoke": "컴퓨터 연결 해제",
+  "remote.revokeConfirm": "{name} 연결을 해제할까요? 이 컴퓨터의 활성 세션이 중지됩니다.",
+  "remote.newSession": "새 원격 세션",
+  "remote.device": "컴퓨터",
+  "remote.folder": "워크스페이스 폴더",
+  "remote.runtime": "코딩 에이전트",
+  "remote.access": "워크스페이스 권한",
+  "remote.access.readOnly": "읽기 전용",
+  "remote.access.workspace": "파일 편집 및 명령 실행",
+  "remote.access.workspaceFilesOnly": "파일 편집만",
+  "remote.unavailable": "사용 불가",
+  "remote.capability.full": "파일 + 격리된 명령 실행",
+  "remote.capability.files": "파일 도구만 지원",
+  "remote.runsOnHub": "모델과 로그인은 이 Hub에서 유지",
+  "remote.runsReadOnly": "이 컴퓨터의 파일은 읽기만 가능",
+  "remote.runsFilesCommands": "파일, 빌드, 명령은 이 컴퓨터에서 실행",
+  "remote.runsFilesOnly": "파일 도구만 이 컴퓨터에서 실행, 명령 격리 미지원",
+  "remote.execUnavailable": "이 컴퓨터의 파일은 편집할 수 있지만, 지원되는 OS 격리 기능이 없어 빌드와 터미널 명령은 비활성화됩니다.",
+  "remote.notResumable": "코딩 에이전트가 세션 기록을 만들기 전에 중단되었습니다. 새 원격 세션을 시작하세요.",
+  "remote.startSession": "원격 세션 시작",
+  "remote.sessionStarted": "원격 세션이 준비되었습니다.",
+  "remote.sessions": "세션",
+  "remote.noSessions": "온라인 컴퓨터, 폴더, 코딩 에이전트를 선택해 시작하세요.",
+  "remote.events": "원격 세션 활동",
+  "remote.noEvents": "아직 활동이 없습니다.",
+  "remote.prompt": "메시지",
+  "remote.promptPlaceholder": "Hub 에이전트에게 선택한 원격 폴더에서 작업을 요청하세요…",
+  "remote.send": "보내기",
+  "remote.stop": "세션 중지",
+  "remote.requestFailed": "원격 워크스페이스 요청에 실패했습니다.",
+  "remote.submissionUnknown": "전송 여부를 확인하지 못했습니다. 다시 보내기 전에 세션 상태를 확인하세요.",
+  "remote.status.starting": "시작 중",
+  "remote.status.ready": "준비됨",
+  "remote.status.running": "실행 중",
+  "remote.status.waiting": "실행기 오프라인",
+  "remote.status.failed": "실패",
+  "remote.status.stopped": "중지됨",
+  "remote.event.status": "상태",
+  "remote.event.tool": "원격 도구",
+  "remote.event.error": "오류",
 };
diff --git a/gui/src/i18n/ru.ts b/gui/src/i18n/ru.ts
index 277cb49175..a6a549f33b 100644
--- a/gui/src/i18n/ru.ts
+++ b/gui/src/i18n/ru.ts
@@ -2742,4 +2742,65 @@ export const ru: Record<TKey, string> = {
   "models.pickerOrder.saveDraft": "Сохранить черновик",
   "models.pickerOrder.reloadDraft": "Перезагрузить и сбросить черновик",
   "models.pickerOrder.catalogRequired": "Идентификаторы моделей отсутствуют или неоднозначны. Перезагрузите страницу моделей, чтобы обновить каталог перед редактированием порядка.",
+  "nav.remote": "Удалённое рабочее пространство",
+  "remote.title": "Удалённое рабочее пространство",
+  "remote.subtitle": "Codex, Claude Code или Pi работают на этом Hub, а файлы, команды, тесты и сборки остаются на выбранном компьютере.",
+  "remote.loading": "Загрузка удалённого рабочего пространства…",
+  "remote.loadFailed": "Не удалось загрузить удалённое рабочее пространство.",
+  "remote.hubRequired": "Для включения Remote Workspace запустите Hub в режиме Hub с OCX_REMOTE_WORKSPACE_ENABLED=1.",
+  "remote.refresh": "Обновить",
+  "remote.addComputer": "Добавить компьютер",
+  "remote.addComputerHint": "Разрешите локальные папки и держите исполнитель только с OCX подключённым к этому Hub.",
+  "remote.createPairing": "Создать код сопряжения",
+  "remote.pairingCode": "Одноразовый код сопряжения",
+  "remote.pairingExpires": "Истекает в {time}",
+  "remote.pairingCommand": "Запустите на добавляемом компьютере",
+  "remote.pairingCommandPosix": "Терминал Linux / macOS",
+  "remote.pairingCommandWindows": "Windows PowerShell",
+  "remote.copyCommand": "Копировать команду",
+  "remote.copied": "Скопировано",
+  "remote.devices": "Компьютеры",
+  "remote.noDevices": "Сопряжённых компьютеров пока нет.",
+  "remote.online": "В сети",
+  "remote.offline": "Не в сети",
+  "remote.revoke": "Отозвать компьютер",
+  "remote.revokeConfirm": "Отозвать {name}? Активные сеансы на этом компьютере будут остановлены.",
+  "remote.newSession": "Новый удалённый сеанс",
+  "remote.device": "Компьютер",
+  "remote.folder": "Папка рабочего пространства",
+  "remote.runtime": "Агент программирования",
+  "remote.access": "Доступ к рабочей области",
+  "remote.access.readOnly": "Только чтение",
+  "remote.access.workspace": "Изменять файлы и выполнять команды",
+  "remote.access.workspaceFilesOnly": "Только изменять файлы",
+  "remote.unavailable": "Недоступно",
+  "remote.capability.full": "Файлы + изолированные команды",
+  "remote.capability.files": "Только файловые инструменты",
+  "remote.runsOnHub": "Модель и вход остаются на этом Hub",
+  "remote.runsReadOnly": "Файлы на этом компьютере доступны только для чтения",
+  "remote.runsFilesCommands": "Файлы, сборки и команды выполняются здесь",
+  "remote.runsFilesOnly": "Здесь работают только файловые инструменты; песочница команд недоступна",
+  "remote.execUnavailable": "На этом компьютере можно редактировать файлы, но сборки и команды терминала отключены без поддерживаемой системной песочницы.",
+  "remote.notResumable": "Сеанс остановился до создания постоянной истории агентом. Запустите новый удалённый сеанс.",
+  "remote.startSession": "Запустить удалённый сеанс",
+  "remote.sessionStarted": "Удалённый сеанс готов.",
+  "remote.sessions": "Сеансы",
+  "remote.noSessions": "Выберите компьютер в сети, папку и агента программирования.",
+  "remote.events": "Активность удалённого сеанса",
+  "remote.noEvents": "Активности пока нет.",
+  "remote.prompt": "Сообщение",
+  "remote.promptPlaceholder": "Попросите агент Hub работать в выбранной удалённой папке…",
+  "remote.send": "Отправить",
+  "remote.stop": "Остановить сеанс",
+  "remote.requestFailed": "Запрос удалённого рабочего пространства завершился ошибкой.",
+  "remote.submissionUnknown": "Статус отправки неизвестен. Проверьте сеанс перед повторной отправкой.",
+  "remote.status.starting": "Запуск",
+  "remote.status.ready": "Готово",
+  "remote.status.running": "Выполняется",
+  "remote.status.waiting": "Исполнитель не в сети",
+  "remote.status.failed": "Ошибка",
+  "remote.status.stopped": "Остановлено",
+  "remote.event.status": "Состояние",
+  "remote.event.tool": "Удалённый инструмент",
+  "remote.event.error": "Ошибка",
 };
diff --git a/gui/src/i18n/tr.ts b/gui/src/i18n/tr.ts
index f280f08f68..22d4c53dac 100644
--- a/gui/src/i18n/tr.ts
+++ b/gui/src/i18n/tr.ts
@@ -2742,4 +2742,65 @@ export const tr: Record<TKey, string> = {
   "models.pickerOrder.saveDraft": "Taslağı kaydet",
   "models.pickerOrder.reloadDraft": "Yeniden yükle ve taslağı sil",
   "models.pickerOrder.catalogRequired": "Model kimlikleri eksik veya belirsiz. Özel sırayı düzenlemeden önce kataloğu yenilemek için Modeller sayfasını yeniden yükleyin.",
+  "nav.remote": "Uzak Çalışma Alanı",
+  "remote.title": "Uzak Çalışma Alanı",
+  "remote.subtitle": "Codex, Claude Code veya Pi bu Hub üzerinde çalışır; dosyalar, komutlar, testler ve derlemeler seçtiğiniz bilgisayarda kalır.",
+  "remote.loading": "Uzak çalışma alanı yükleniyor…",
+  "remote.loadFailed": "Uzak çalışma alanı yüklenemedi.",
+  "remote.hubRequired": "Remote Workspace özelliğini açmak için Hub modunda OCX_REMOTE_WORKSPACE_ENABLED=1 ile Hub başlatın.",
+  "remote.refresh": "Yenile",
+  "remote.addComputer": "Bilgisayar ekle",
+  "remote.addComputerHint": "Klasörleri yerel olarak onaylayın ve yalnızca OCX kurulu yürütücüyü bu Hub'a bağlı tutun.",
+  "remote.createPairing": "Eşleştirme kodu oluştur",
+  "remote.pairingCode": "Tek kullanımlık eşleştirme kodu",
+  "remote.pairingExpires": "{time} saatinde sona erer",
+  "remote.pairingCommand": "Eklenecek bilgisayarda çalıştırın",
+  "remote.pairingCommandPosix": "Linux / macOS terminali",
+  "remote.pairingCommandWindows": "Windows PowerShell",
+  "remote.copyCommand": "Komutu kopyala",
+  "remote.copied": "Kopyalandı",
+  "remote.devices": "Bilgisayarlar",
+  "remote.noDevices": "Henüz eşleştirilmiş bilgisayar yok.",
+  "remote.online": "Çevrimiçi",
+  "remote.offline": "Çevrimdışı",
+  "remote.revoke": "Bilgisayarı iptal et",
+  "remote.revokeConfirm": "{name} iptal edilsin mi? Bu bilgisayardaki etkin oturumlar durur.",
+  "remote.newSession": "Yeni uzak oturum",
+  "remote.device": "Bilgisayar",
+  "remote.folder": "Çalışma alanı klasörü",
+  "remote.runtime": "Kodlama aracısı",
+  "remote.access": "Çalışma alanı erişimi",
+  "remote.access.readOnly": "Salt okunur",
+  "remote.access.workspace": "Dosyaları düzenle ve komut çalıştır",
+  "remote.access.workspaceFilesOnly": "Yalnızca dosyaları düzenle",
+  "remote.unavailable": "Kullanılamıyor",
+  "remote.capability.full": "Dosyalar + yalıtılmış komutlar",
+  "remote.capability.files": "Yalnızca dosya araçları",
+  "remote.runsOnHub": "Model ve oturum bu Hub üzerinde kalır",
+  "remote.runsReadOnly": "Bu bilgisayardaki dosyalar yalnızca okunabilir",
+  "remote.runsFilesCommands": "Dosyalar, derlemeler ve komutlar burada çalışır",
+  "remote.runsFilesOnly": "Burada yalnızca dosya araçları çalışır; komut yalıtımı yok",
+  "remote.execUnavailable": "Bu bilgisayar dosyaları düzenleyebilir; ancak desteklenen bir işletim sistemi yalıtımı olmadığı için derlemeler ve terminal komutları devre dışıdır.",
+  "remote.notResumable": "Kodlama aracısı kalıcı geçmiş oluşturmadan önce oturum durdu. Yeni bir uzak oturum başlatın.",
+  "remote.startSession": "Uzak oturumu başlat",
+  "remote.sessionStarted": "Uzak oturum hazır.",
+  "remote.sessions": "Oturumlar",
+  "remote.noSessions": "Çevrimiçi bir bilgisayar, klasör ve kodlama aracısı seçin.",
+  "remote.events": "Uzak oturum etkinliği",
+  "remote.noEvents": "Henüz etkinlik yok.",
+  "remote.prompt": "Mesaj",
+  "remote.promptPlaceholder": "Hub aracısından seçili uzak klasörde çalışmasını isteyin…",
+  "remote.send": "Gönder",
+  "remote.stop": "Oturumu durdur",
+  "remote.requestFailed": "Uzak çalışma alanı isteği başarısız oldu.",
+  "remote.submissionUnknown": "Gönderim durumu bilinmiyor. Yeniden göndermeden önce oturumu kontrol edin.",
+  "remote.status.starting": "Başlatılıyor",
+  "remote.status.ready": "Hazır",
+  "remote.status.running": "Çalışıyor",
+  "remote.status.waiting": "Yürütücü çevrimdışı",
+  "remote.status.failed": "Başarısız",
+  "remote.status.stopped": "Durduruldu",
+  "remote.event.status": "Durum",
+  "remote.event.tool": "Uzak araç",
+  "remote.event.error": "Hata",
 };
diff --git a/gui/src/i18n/zh-TW.ts b/gui/src/i18n/zh-TW.ts
index 688cf590f5..352b5d8afa 100644
--- a/gui/src/i18n/zh-TW.ts
+++ b/gui/src/i18n/zh-TW.ts
@@ -2705,4 +2705,65 @@ export const zhTW: Record<TKey, string> = {
   "models.pickerOrder.saveDraft": "儲存草稿",
   "models.pickerOrder.reloadDraft": "捨棄草稿並重新載入",
   "models.pickerOrder.catalogRequired": "模型識別資訊缺失或不明確。請重新載入模型頁面以更新目錄，再編輯自訂順序。",
+  "nav.remote": "遠端工作區",
+  "remote.title": "遠端工作區",
+  "remote.subtitle": "Codex、Claude Code 或 Pi 在此 Hub 執行，檔案、命令、測試與建置則留在所選電腦上處理。",
+  "remote.loading": "正在載入遠端工作區…",
+  "remote.loadFailed": "無法載入遠端工作區。",
+  "remote.hubRequired": "請在 Hub 模式下使用 OCX_REMOTE_WORKSPACE_ENABLED=1 啟動 Hub，以啟用遠端工作區。",
+  "remote.refresh": "重新整理",
+  "remote.addComputer": "新增電腦",
+  "remote.addComputerHint": "在本機核准一個或多個資料夾，並讓僅安裝 OCX 的執行端持續連線此 Hub。",
+  "remote.createPairing": "建立配對碼",
+  "remote.pairingCode": "一次性配對碼",
+  "remote.pairingExpires": "{time} 到期",
+  "remote.pairingCommand": "在要新增的電腦上執行",
+  "remote.pairingCommandPosix": "Linux / macOS 終端機",
+  "remote.pairingCommandWindows": "Windows PowerShell",
+  "remote.copyCommand": "複製命令",
+  "remote.copied": "已複製",
+  "remote.devices": "電腦",
+  "remote.noDevices": "尚未配對電腦。",
+  "remote.online": "上線",
+  "remote.offline": "離線",
+  "remote.revoke": "撤銷電腦",
+  "remote.revokeConfirm": "撤銷 {name}？此電腦上的作用中工作階段將停止。",
+  "remote.newSession": "新增遠端工作階段",
+  "remote.device": "電腦",
+  "remote.folder": "工作區資料夾",
+  "remote.runtime": "程式設計代理",
+  "remote.access": "工作區權限",
+  "remote.access.readOnly": "唯讀",
+  "remote.access.workspace": "編輯檔案並執行命令",
+  "remote.access.workspaceFilesOnly": "僅編輯檔案",
+  "remote.unavailable": "無法使用",
+  "remote.capability.full": "檔案 + 沙箱命令",
+  "remote.capability.files": "僅檔案工具",
+  "remote.runsOnHub": "模型與登入保留在此 Hub",
+  "remote.runsReadOnly": "此電腦上的檔案僅可讀取",
+  "remote.runsFilesCommands": "檔案、建置與命令在此電腦執行",
+  "remote.runsFilesOnly": "僅檔案工具在此執行；命令沙箱無法使用",
+  "remote.execUnavailable": "此電腦可以編輯檔案，但因沒有支援的作業系統沙箱，建置與終端命令已停用。",
+  "remote.notResumable": "程式設計代理尚未建立持久歷史記錄時工作階段就已停止。請啟動新的遠端工作階段。",
+  "remote.startSession": "啟動遠端工作階段",
+  "remote.sessionStarted": "遠端工作階段已就緒。",
+  "remote.sessions": "工作階段",
+  "remote.noSessions": "請選擇上線電腦、資料夾與程式設計代理。",
+  "remote.events": "遠端工作階段活動",
+  "remote.noEvents": "尚無活動。",
+  "remote.prompt": "訊息",
+  "remote.promptPlaceholder": "請 Hub 代理在所選遠端資料夾中工作…",
+  "remote.send": "傳送",
+  "remote.stop": "停止工作階段",
+  "remote.requestFailed": "遠端工作區要求失敗。",
+  "remote.submissionUnknown": "無法確認傳送狀態。請先檢查工作階段，再決定是否重新傳送。",
+  "remote.status.starting": "正在啟動",
+  "remote.status.ready": "就緒",
+  "remote.status.running": "執行中",
+  "remote.status.waiting": "執行端離線",
+  "remote.status.failed": "失敗",
+  "remote.status.stopped": "已停止",
+  "remote.event.status": "狀態",
+  "remote.event.tool": "遠端工具",
+  "remote.event.error": "錯誤",
 };
diff --git a/gui/src/i18n/zh.ts b/gui/src/i18n/zh.ts
index bcf995f4c1..b69aba3eea 100644
--- a/gui/src/i18n/zh.ts
+++ b/gui/src/i18n/zh.ts
@@ -2740,4 +2740,65 @@ export const zh: Record<TKey, string> = {
   "models.pickerOrder.saveDraft": "保存草稿",
   "models.pickerOrder.reloadDraft": "丢弃草稿并重新加载",
   "models.pickerOrder.catalogRequired": "模型标识信息缺失或不明确。请重新加载模型页面以刷新目录，再编辑自定义顺序。",
+  "nav.remote": "远程工作区",
+  "remote.title": "远程工作区",
+  "remote.subtitle": "Codex、Claude Code 或 Pi 在此 Hub 上运行，文件、命令、测试和构建则留在所选电脑上执行。",
+  "remote.loading": "正在加载远程工作区…",
+  "remote.loadFailed": "无法加载远程工作区。",
+  "remote.hubRequired": "请在 Hub 模式下使用 OCX_REMOTE_WORKSPACE_ENABLED=1 启动 Hub，以启用远程工作区。",
+  "remote.refresh": "刷新",
+  "remote.addComputer": "添加电脑",
+  "remote.addComputerHint": "在本机批准一个或多个文件夹，并让仅安装 OCX 的执行端持续连接此 Hub。",
+  "remote.createPairing": "创建配对码",
+  "remote.pairingCode": "一次性配对码",
+  "remote.pairingExpires": "{time} 过期",
+  "remote.pairingCommand": "在要添加的电脑上运行",
+  "remote.pairingCommandPosix": "Linux / macOS 终端",
+  "remote.pairingCommandWindows": "Windows PowerShell",
+  "remote.copyCommand": "复制命令",
+  "remote.copied": "已复制",
+  "remote.devices": "电脑",
+  "remote.noDevices": "尚未配对电脑。",
+  "remote.online": "在线",
+  "remote.offline": "离线",
+  "remote.revoke": "撤销电脑",
+  "remote.revokeConfirm": "撤销 {name}？该电脑上的活动会话将停止。",
+  "remote.newSession": "新建远程会话",
+  "remote.device": "电脑",
+  "remote.folder": "工作区文件夹",
+  "remote.runtime": "编程代理",
+  "remote.access": "工作区权限",
+  "remote.access.readOnly": "只读",
+  "remote.access.workspace": "编辑文件并运行命令",
+  "remote.access.workspaceFilesOnly": "仅编辑文件",
+  "remote.unavailable": "不可用",
+  "remote.capability.full": "文件 + 沙箱命令",
+  "remote.capability.files": "仅文件工具",
+  "remote.runsOnHub": "模型和登录保留在此 Hub",
+  "remote.runsReadOnly": "此电脑上的文件仅可读取",
+  "remote.runsFilesCommands": "文件、构建和命令在此电脑运行",
+  "remote.runsFilesOnly": "仅文件工具在此运行；命令沙箱不可用",
+  "remote.execUnavailable": "此电脑可以编辑文件，但由于没有受支持的操作系统沙箱，构建和终端命令已禁用。",
+  "remote.notResumable": "编码代理尚未创建持久历史记录时会话就已停止。请启动新的远程会话。",
+  "remote.startSession": "启动远程会话",
+  "remote.sessionStarted": "远程会话已就绪。",
+  "remote.sessions": "会话",
+  "remote.noSessions": "请选择在线电脑、文件夹和编程代理。",
+  "remote.events": "远程会话活动",
+  "remote.noEvents": "暂无活动。",
+  "remote.prompt": "消息",
+  "remote.promptPlaceholder": "让 Hub 代理在所选远程文件夹中工作…",
+  "remote.send": "发送",
+  "remote.stop": "停止会话",
+  "remote.requestFailed": "远程工作区请求失败。",
+  "remote.submissionUnknown": "无法确认发送状态。请先检查会话，再决定是否重新发送。",
+  "remote.status.starting": "正在启动",
+  "remote.status.ready": "就绪",
+  "remote.status.running": "运行中",
+  "remote.status.waiting": "执行端离线",
+  "remote.status.failed": "失败",
+  "remote.status.stopped": "已停止",
+  "remote.event.status": "状态",
+  "remote.event.tool": "远程工具",
+  "remote.event.error": "错误",
 };
diff --git a/gui/src/pages/RemoteWorkspace.tsx b/gui/src/pages/RemoteWorkspace.tsx
new file mode 100644
index 0000000000..d6eebb3258
--- /dev/null
+++ b/gui/src/pages/RemoteWorkspace.tsx
@@ -0,0 +1,411 @@
+import { useMemo, useRef, useState } from "react";
+import { useKeyedClientResource } from "../client-resource";
+import { readJsonOrThrow } from "../fetch-json";
+import { IconLink, IconMonitor, IconPlus, IconRefresh, IconTerminal, IconTrash } from "../icons";
+import { type TKey, useT } from "../i18n/shared";
+import { Notice, Select } from "../ui";
+import { remoteWorkspacePairingCommands } from "../remote-workspace-command";
+
+type RuntimeProfile = "codex" | "claude" | "pi";
+type RemoteCapability = "workspace.read" | "workspace.write" | "workspace.exec";
+type RemoteAccessMode = "read-only" | "workspace";
+type SessionStatus = "starting" | "ready" | "running" | "waiting_for_executor" | "failed" | "stopped";
+
+interface RemoteRoot { id: string; label: string }
+interface RemoteDevice {
+  id: string;
+  name: string;
+  platform: string;
+  capabilities: RemoteCapability[];
+  roots: RemoteRoot[];
+  online: boolean;
+  createdAt: string;
+  lastSeenAt: string | null;
+}
+interface RuntimeAvailability { available: boolean; version?: string; reason?: string }
+interface SessionEvent { sequence: number; at: string; type: "status" | "assistant" | "tool" | "error"; text: string }
+interface RemoteSession {
+  id: string;
+  profile: RuntimeProfile;
+  accessMode: RemoteAccessMode;
+  deviceId: string;
+  deviceName: string;
+  rootId: string;
+  rootLabel: string;
+  capabilities: RemoteCapability[];
+  tools: string[];
+  threadId: string | null;
+  resumable: boolean;
+  status: SessionStatus;
+  createdAt: string;
+  updatedAt: string;
+  events: SessionEvent[];
+}
+interface RemoteWorkspaceState {
+  available: boolean;
+  reason?: string;
+  devices: RemoteDevice[];
+  runtimes: Record<RuntimeProfile, RuntimeAvailability>;
+  sessions: RemoteSession[];
+}
+interface PairingGrant { code: string; expiresAt: string }
+
+const PROFILES: RuntimeProfile[] = ["codex", "claude", "pi"];
+const PROFILE_LABEL: Record<RuntimeProfile, string> = { codex: "Codex", claude: "Claude Code", pi: "Pi" };
+const STATUS_TKEY: Record<SessionStatus, TKey> = {
+  starting: "remote.status.starting",
+  ready: "remote.status.ready",
+  running: "remote.status.running",
+  waiting_for_executor: "remote.status.waiting",
+  failed: "remote.status.failed",
+  stopped: "remote.status.stopped",
+};
+const EVENT_TKEY: Record<Exclude<SessionEvent["type"], "assistant">, TKey> = {
+  status: "remote.event.status",
+  tool: "remote.event.tool",
+  error: "remote.event.error",
+};
+
+function isRuntimeProfile(value: string): value is RuntimeProfile {
+  return value === "codex" || value === "claude" || value === "pi";
+}
+
+function isRemoteAccessMode(value: string): value is RemoteAccessMode {
+  return value === "read-only" || value === "workspace";
+}
+
+async function copyText(text: string): Promise<boolean> {
+  try {
+    await navigator.clipboard.writeText(text);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export default function RemoteWorkspace({ apiBase, hubOrigin }: { apiBase: string; hubOrigin: string }) {
+  const t = useT();
+  const resource = useKeyedClientResource(
+    `remote-workspace:${apiBase}`,
+    [apiBase],
+    async signal => {
+      const response = await fetch(`${apiBase}/api/remote-workspace`, { signal, cache: "no-store" });
+      return await readJsonOrThrow<RemoteWorkspaceState>(response, t("remote.loadFailed"));
+    },
+    { pollMs: 3_000, deadlineMs: 10_000 },
+  );
+  const state = resource.data;
+  const [selectedDeviceId, setSelectedDeviceId] = useState("");
+  const [selectedRootId, setSelectedRootId] = useState("");
+  const [selectedProfile, setSelectedProfile] = useState<RuntimeProfile>("codex");
+  const [selectedAccessMode, setSelectedAccessMode] = useState<RemoteAccessMode>("read-only");
+  const [selectedSessionId, setSelectedSessionId] = useState("");
+  const [localSession, setLocalSession] = useState<RemoteSession | null>(null);
+  const [pairing, setPairing] = useState<PairingGrant | null>(null);
+  const [drafts, setDrafts] = useState<Record<string, string>>({});
+  const [busy, setBusy] = useState<"pair" | "session" | "revoke" | null>(null);
+  const [promptPending, setPromptPending] = useState(false);
+  const [stopPending, setStopPending] = useState(false);
+  const stoppedSessionId = useRef<string | null>(null);
+  const [notice, setNotice] = useState<{ tone: "ok" | "err"; text: string } | null>(null);
+  const [copiedCommand, setCopiedCommand] = useState<"posix" | "powershell" | null>(null);
+
+  const devices = state?.devices ?? [];
+  const effectiveDevice = devices.find(device => device.id === selectedDeviceId)
+    ?? devices.find(device => device.online)
+    ?? devices[0]
+    ?? null;
+  const effectiveRoot = effectiveDevice?.roots.find(root => root.id === selectedRootId)
+    ?? effectiveDevice?.roots[0]
+    ?? null;
+  const selectedCanExecute = selectedAccessMode === "workspace"
+    && (effectiveDevice?.capabilities.includes("workspace.exec") ?? false);
+  const workspaceAccessLabel = effectiveDevice && !effectiveDevice.capabilities.includes("workspace.exec")
+    ? t("remote.access.workspaceFilesOnly")
+    : t("remote.access.workspace");
+  const availableProfiles = PROFILES.filter(profile => state?.runtimes?.[profile]?.available);
+  const effectiveProfile = availableProfiles.includes(selectedProfile)
+    ? selectedProfile
+    : availableProfiles[0] ?? selectedProfile;
+  const remoteSessions = state?.sessions ?? [];
+  const fallbackSession = [...remoteSessions].reverse().find(session => session.status !== "stopped");
+  const candidate = remoteSessions.find(session => session.id === selectedSessionId)
+    ?? (localSession?.id === selectedSessionId ? localSession : null)
+    ?? fallbackSession
+    ?? localSession;
+  const wantedSessionId = candidate?.id;
+  const polledSession = remoteSessions.find(session => session.id === wantedSessionId);
+  const selectedLocal = localSession?.id === wantedSessionId ? localSession : null;
+  const selectedSession = selectedLocal && (!polledSession
+    || (selectedLocal.events.at(-1)?.sequence ?? 0) > (polledSession.events.at(-1)?.sequence ?? 0))
+    ? selectedLocal : polledSession;
+  const effectiveSession = selectedSession
+    ?? fallbackSession
+    ?? localSession;
+
+  const prompt = drafts[effectiveSession?.id ?? ""] ?? "";
+  const setPrompt = (value: string | ((current: string) => string)) => {
+    const id = effectiveSession?.id;
+    if (!id) return;
+    setDrafts(current => ({ ...current, [id]: typeof value === "function" ? value(current[id] ?? "") : value }));
+  };
+  const stale = Boolean(state && !resource.lastAttemptOk);
+  const canSend = Boolean(effectiveSession && prompt.trim() && busy === null && !promptPending && !stopPending && !stale
+    && effectiveSession.status !== "running" && effectiveSession.status !== "starting"
+    && effectiveSession.status !== "stopped"
+    && !(effectiveSession.status === "failed" && effectiveSession.resumable === false)
+    && !(effectiveSession.status === "waiting_for_executor" && !devices.find(device => device.id === effectiveSession.deviceId)?.online));
+
+  const pairingCommands = useMemo(() => {
+    if (!pairing) return { posix: "", powershell: "" };
+    return remoteWorkspacePairingCommands(pairing.code, hubOrigin);
+  }, [pairing, hubOrigin]);
+
+  const mutate = async <T,>(path: string, init: RequestInit, fallback: string): Promise<T> => {
+    const response = await fetch(`${apiBase}${path}`, init);
+    const body = await readJsonOrThrow<T>(response, fallback);
+    if (body === undefined) throw new Error(fallback);
+    return body;
+  };
+
+  const createPairing = async () => {
+    setBusy("pair");
+    setNotice(null);
+    try {
+      const grant = await mutate<PairingGrant>("/api/remote-workspace/pairing", { method: "POST" }, t("remote.requestFailed"));
+      setPairing(grant);
+      setCopiedCommand(null);
+    } catch (error) {
+      setNotice({ tone: "err", text: error instanceof Error ? error.message : t("remote.requestFailed") });
+    } finally { setBusy(null); }
+  };
+
+  const createSession = async () => {
+    if (!effectiveDevice || !effectiveRoot) return;
+    setBusy("session");
+    setNotice(null);
+    try {
+      const session = await mutate<RemoteSession>("/api/remote-workspace/sessions", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          profile: effectiveProfile,
+          deviceId: effectiveDevice.id,
+          rootId: effectiveRoot.id,
+          accessMode: selectedAccessMode,
+        }),
+      }, t("remote.requestFailed"));
+      setLocalSession(session);
+      setSelectedSessionId(session.id);
+      setNotice({ tone: "ok", text: t("remote.sessionStarted") });
+      void resource.refresh();
+    } catch (error) {
+      setNotice({ tone: "err", text: error instanceof Error ? error.message : t("remote.requestFailed") });
+    } finally { setBusy(null); }
+  };
+
+  const sendPrompt = async () => {
+    if (!effectiveSession || !canSend) return;
+    const target = effectiveSession;
+    const submitted = prompt;
+    setPromptPending(true);
+    setNotice(null);
+    let responseStatus: number | undefined;
+    try {
+      const response = await fetch(`${apiBase}/api/remote-workspace/sessions/${target.id}/prompt`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ prompt: submitted }),
+      });
+      responseStatus = response.status;
+      const session = await readJsonOrThrow<RemoteSession>(response, t("remote.requestFailed"));
+      if (!session) throw new Error(t("remote.requestFailed"));
+      setPrompt(current => current === submitted ? "" : current);
+      if (stoppedSessionId.current !== target.id) setLocalSession(session);
+      void resource.refresh();
+    } catch (error) {
+      if (stoppedSessionId.current !== target.id) {
+        const rejected = responseStatus !== undefined && responseStatus >= 400 && responseStatus < 500;
+        setNotice({ tone: "err", text: rejected
+          ? error instanceof Error ? error.message : t("remote.requestFailed")
+          : t("remote.submissionUnknown") });
+        void resource.refresh();
+      }
+    } finally { setPromptPending(false); }
+  };
+
+  const stopSession = async () => {
+    if (!effectiveSession || stopPending) return;
+    const target = effectiveSession;
+    setStopPending(true);
+    try {
+      await mutate(`/api/remote-workspace/sessions/${target.id}`, { method: "DELETE" }, t("remote.requestFailed"));
+      stoppedSessionId.current = target.id;
+      setLocalSession({ ...target, status: "stopped" });
+      void resource.refresh();
+    } catch (error) {
+      setNotice({ tone: "err", text: error instanceof Error ? error.message : t("remote.requestFailed") });
+    } finally { setStopPending(false); }
+  };
+
+  const revokeDevice = async (device: RemoteDevice) => {
+    if (!confirm(t("remote.revokeConfirm", { name: device.name }))) return;
+    setBusy("revoke");
+    try {
+      await mutate(`/api/remote-workspace/devices/${device.id}`, { method: "DELETE" }, t("remote.requestFailed"));
+      if (selectedDeviceId === device.id) setSelectedDeviceId("");
+      void resource.refresh();
+    } catch (error) {
+      setNotice({ tone: "err", text: error instanceof Error ? error.message : t("remote.requestFailed") });
+    } finally { setBusy(null); }
+  };
+
+  const copyPairingCommand = async (kind: "posix" | "powershell", command: string) => {
+    setCopiedCommand(await copyText(command) ? kind : null);
+  };
+
+  if (resource.loading && !state) return <div className="alert">{t("remote.loading")}</div>;
+  if (resource.error && !state) {
+    return <><Notice tone="err">{t("remote.loadFailed")}</Notice><button type="button" className="btn btn-ghost" onClick={() => void resource.refresh()}>{t("common.retry")}</button></>;
+  }
+  if (state?.available === false) return <Notice tone="err">{t("remote.hubRequired")}</Notice>;
+
+  return (
+    <section className="remote-workspace-page">
+      <div className="page-head">
+        <div>
+          <h2>{t("remote.title")}</h2>
+          <p className="page-sub">{t("remote.subtitle")}</p>
+        </div>
+        <button type="button" className="btn btn-ghost btn-sm" onClick={() => void resource.refresh()} disabled={resource.refreshing}>
+          <IconRefresh /> {t("remote.refresh")}
+        </button>
+      </div>
+
+      {stale ? <Notice tone="err">{t("remote.loadFailed")}</Notice> : null}
+      {notice ? <Notice tone={notice.tone}>{notice.text}</Notice> : null}
+
+      <div className="remote-workspace-grid">
+        <div className="remote-workspace-column">
+          <article className="panel panel-accent remote-pair-card">
+            <div className="remote-panel-head">
+              <div className="remote-icon"><IconLink /></div>
+              <div><h3>{t("remote.addComputer")}</h3><p>{t("remote.addComputerHint")}</p></div>
+            </div>
+            <button type="button" className="btn btn-primary" onClick={() => void createPairing()} disabled={busy !== null}>
+              <IconPlus /> {t("remote.createPairing")}
+            </button>
+            {pairing ? (
+              <div className="remote-pairing-result">
+                <span className="field-label">{t("remote.pairingCode")}</span>
+                <div className="remote-pairing-code">{pairing.code}</div>
+                <div className="remote-expiry">{t("remote.pairingExpires", { time: new Date(pairing.expiresAt).toLocaleTimeString() })}</div>
+                <span className="field-label">{t("remote.pairingCommandPosix")}</span>
+                <pre><code>{pairingCommands.posix}</code></pre>
+                <button type="button" className="btn btn-ghost btn-sm" onClick={() => void copyPairingCommand("posix", pairingCommands.posix)}>
+                  {copiedCommand === "posix" ? t("remote.copied") : t("remote.copyCommand")}
+                </button>
+                <span className="field-label">{t("remote.pairingCommandWindows")}</span>
+                <pre><code>{pairingCommands.powershell}</code></pre>
+                <button type="button" className="btn btn-ghost btn-sm" onClick={() => void copyPairingCommand("powershell", pairingCommands.powershell)}>
+                  {copiedCommand === "powershell" ? t("remote.copied") : t("remote.copyCommand")}
+                </button>
+              </div>
+            ) : null}
+          </article>
+
+          <section className="panel remote-device-panel">
+            <div className="remote-section-title"><h3>{t("remote.devices")}</h3><span>{devices.length}</span></div>
+            {devices.length === 0 ? <p className="remote-empty">{t("remote.noDevices")}</p> : (
+              <div className="remote-device-list">
+                {devices.map(device => (
+                  <div
+                    key={device.id}
+                    className={`remote-device${effectiveDevice?.id === device.id ? " selected" : ""}`}
+                  >
+                    <button
+                      type="button"
+                      className="remote-device-main"
+                      onClick={() => { setSelectedDeviceId(device.id); setSelectedRootId(device.roots[0]?.id ?? ""); }}
+                      aria-pressed={effectiveDevice?.id === device.id}
+                    >
+                      <span className={`remote-online-dot${device.online ? " online" : ""}`} />
+                      <span className="remote-device-copy"><strong>{device.name}</strong><small>{device.platform} · {device.online ? t("remote.online") : t("remote.offline")} · {device.capabilities.includes("workspace.exec") ? t("remote.capability.full") : t("remote.capability.files")}</small></span>
+                    </button>
+                    <button
+                      type="button"
+                      className="remote-revoke"
+                      aria-label={t("remote.revoke")}
+                      disabled={busy !== null || promptPending || stopPending}
+                      onClick={() => void revokeDevice(device)}
+                    ><IconTrash /></button>
+                  </div>
+                ))}
+              </div>
+            )}
+          </section>
+        </div>
+
+        <div className="remote-workspace-column remote-session-column">
+          <section className="panel remote-launch-panel">
+            <div className="remote-section-title"><h3>{t("remote.newSession")}</h3><IconMonitor /></div>
+            <div className="remote-launch-fields">
+              <label><span className="field-label">{t("remote.device")}</span><Select value={effectiveDevice?.id ?? ""} options={devices.map(device => ({ value: device.id, label: device.name }))} onChange={value => { setSelectedDeviceId(value); setSelectedRootId(devices.find(device => device.id === value)?.roots[0]?.id ?? ""); }} label={t("remote.device")} disabled={devices.length === 0} /></label>
+              <label><span className="field-label">{t("remote.folder")}</span><Select value={effectiveRoot?.id ?? ""} options={(effectiveDevice?.roots ?? []).map(root => ({ value: root.id, label: root.label }))} onChange={setSelectedRootId} label={t("remote.folder")} disabled={!effectiveDevice} /></label>
+              <label><span className="field-label">{t("remote.runtime")}</span><Select value={effectiveProfile} options={PROFILES.map(profile => ({ value: profile, label: state?.runtimes?.[profile]?.available ? PROFILE_LABEL[profile] : `${PROFILE_LABEL[profile]} · ${t("remote.unavailable")}` }))} onChange={value => { if (isRuntimeProfile(value)) setSelectedProfile(value); }} label={t("remote.runtime")} /></label>
+              <label><span className="field-label">{t("remote.access")}</span><Select value={selectedAccessMode} options={[{ value: "read-only", label: t("remote.access.readOnly") }, { value: "workspace", label: workspaceAccessLabel }]} onChange={value => { if (isRemoteAccessMode(value)) setSelectedAccessMode(value); }} label={t("remote.access")} /></label>
+            </div>
+            {effectiveDevice ? (
+              <div className="remote-execution-map">
+                <span><strong>{PROFILE_LABEL[effectiveProfile]}</strong>{t("remote.runsOnHub")}</span>
+                <span><strong>{effectiveDevice.name}</strong>{selectedAccessMode === "read-only" ? t("remote.runsReadOnly") : selectedCanExecute ? t("remote.runsFilesCommands") : t("remote.runsFilesOnly")}</span>
+              </div>
+            ) : null}
+            {selectedAccessMode === "workspace" && !selectedCanExecute && effectiveDevice ? <Notice tone="err">{t("remote.execUnavailable")}</Notice> : null}
+            {!state?.runtimes?.[effectiveProfile]?.available && state?.runtimes?.[effectiveProfile]?.reason
+              ? <p className="remote-runtime-reason">{state.runtimes[effectiveProfile].reason}</p>
+              : null}
+            <button type="button" className="btn btn-primary remote-start" onClick={() => void createSession()} disabled={!effectiveDevice?.online || !effectiveRoot || !state?.runtimes?.[effectiveProfile]?.available || busy !== null || promptPending || stopPending}>
+              <IconTerminal /> {t("remote.startSession")}
+            </button>
+          </section>
+
+          <section className="panel remote-console-panel">
+            <div className="remote-section-title">
+              <div><h3>{t("remote.sessions")}</h3>{effectiveSession ? <small>{PROFILE_LABEL[effectiveSession.profile]} · {effectiveSession.deviceName}/{effectiveSession.rootLabel} · {effectiveSession.accessMode === "read-only" ? t("remote.access.readOnly") : effectiveSession.capabilities.includes("workspace.exec") ? t("remote.access.workspace") : t("remote.access.workspaceFilesOnly")}</small> : null}</div>
+              {effectiveSession ? <span className={`remote-status remote-status--${effectiveSession.status}`}>{t(STATUS_TKEY[effectiveSession.status])}</span> : null}
+            </div>
+            {remoteSessions.length > 1 ? (
+              <Select value={effectiveSession?.id ?? ""} options={remoteSessions.map(session => ({ value: session.id, label: `${PROFILE_LABEL[session.profile]} · ${session.deviceName}/${session.rootLabel}` }))} onChange={setSelectedSessionId} label={t("remote.sessions")} />
+            ) : null}
+            {!effectiveSession ? <p className="remote-empty remote-empty--console">{t("remote.noSessions")}</p> : (
+              <>
+                <div className="remote-events" aria-live="polite" aria-label={t("remote.events")}>
+                  {effectiveSession.events.length === 0 ? <p className="remote-empty">{t("remote.noEvents")}</p> : effectiveSession.events.map(event => (
+                    <div key={event.sequence} className={`remote-event remote-event--${event.type}`}>
+                      <span>{event.type === "assistant" ? PROFILE_LABEL[effectiveSession.profile] : t(EVENT_TKEY[event.type])}</span>
+                      <p>{event.text}</p>
+                    </div>
+                  ))}
+                </div>
+                {effectiveSession.status === "failed" && effectiveSession.resumable === false
+                  ? <Notice tone="err">{t("remote.notResumable")}</Notice>
+                  : null}
+                <label className="remote-composer">
+                  <span className="field-label">{t("remote.prompt")}</span>
+                  <textarea className="input" rows={4} value={prompt} onChange={event => setPrompt(event.target.value)} placeholder={t("remote.promptPlaceholder")} disabled={effectiveSession.status === "stopped" || (effectiveSession.status === "failed" && effectiveSession.resumable === false)} onKeyDown={event => {
+                    if ((event.ctrlKey || event.metaKey) && event.key === "Enter") { event.preventDefault(); void sendPrompt(); }
+                  }} />
+                </label>
+                <div className="remote-console-actions">
+                  <button type="button" className="btn btn-primary" onClick={() => void sendPrompt()} disabled={!canSend}>{t("remote.send")}</button>
+                  <button type="button" className="btn btn-danger" onClick={() => void stopSession()} disabled={stopPending || effectiveSession.status === "stopped"}>{t("remote.stop")}</button>
+                </div>
+              </>
+            )}
+          </section>
+        </div>
+      </div>
+    </section>
+  );
+}
diff --git a/gui/src/remote-workspace-command.ts b/gui/src/remote-workspace-command.ts
new file mode 100644
index 0000000000..050950d1c7
--- /dev/null
+++ b/gui/src/remote-workspace-command.ts
@@ -0,0 +1,18 @@
+function posixQuote(value: string): string {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+
+function powershellQuote(value: string): string {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+
+/** Technical shell samples; kept outside JSX/i18n because command syntax is not prose. */
+export function remoteWorkspacePairingCommands(code: string, hubOrigin: string): {
+  posix: string;
+  powershell: string;
+} {
+  return {
+    posix: `printf '%s\\n' ${posixQuote(code)} | ocx remote-workspace pair ${posixQuote(hubOrigin)} --pairing-code-stdin --root "$PWD" && ocx remote-workspace agent`,
+    powershell: `$pairingCode = ${powershellQuote(code)}; $pairingCode | ocx remote-workspace pair ${powershellQuote(hubOrigin)} --pairing-code-stdin --root (Get-Location).Path; if ($LASTEXITCODE -eq 0) { ocx remote-workspace agent }`,
+  };
+}
diff --git a/gui/src/styles-remote-workspace.css b/gui/src/styles-remote-workspace.css
new file mode 100644
index 0000000000..10adef67e2
--- /dev/null
+++ b/gui/src/styles-remote-workspace.css
@@ -0,0 +1,75 @@
+.remote-workspace-page .page-head { align-items: flex-start; }
+.remote-workspace-page .page-sub { margin-bottom: 0; }
+.remote-workspace-grid { display: grid; grid-template-columns: minmax(280px, .82fr) minmax(420px, 1.35fr); gap: 14px; align-items: start; }
+.remote-workspace-column { display: grid; gap: 14px; min-width: 0; }
+.remote-panel-head { display: flex; align-items: flex-start; gap: 12px; }
+.remote-panel-head h3, .remote-section-title h3 { margin: 0; font-size: var(--text-section); }
+.remote-panel-head p { margin: 3px 0 0; color: var(--muted); font-size: var(--text-label); line-height: var(--leading-body); }
+.remote-icon { display: grid; place-items: center; width: 34px; height: 34px; flex: 0 0 auto; border-radius: var(--radius-sm); color: var(--accent); background: var(--accent-soft); }
+.remote-icon svg { width: 18px; height: 18px; }
+.remote-pair-card { display: grid; gap: 14px; }
+.remote-pair-card > .btn { justify-self: start; }
+.remote-pairing-result { display: grid; gap: 7px; padding-top: 12px; border-top: 1px solid var(--border-soft); }
+.remote-pairing-code { font-family: var(--font-code); font-size: clamp(21px, 3vw, 28px); font-weight: 700; letter-spacing: .11em; color: var(--text); }
+.remote-expiry { margin: -3px 0 4px; color: var(--muted); font-size: var(--text-caption); }
+.remote-pairing-result pre { max-width: 100%; margin: 0; padding: 11px; overflow: auto; border: 1px solid var(--border); border-radius: var(--radius-sm); background: var(--raised); font-size: var(--text-caption); line-height: 1.5; white-space: pre-wrap; overflow-wrap: anywhere; }
+.remote-section-title { display: flex; align-items: center; justify-content: space-between; gap: 12px; margin-bottom: 12px; }
+.remote-section-title > span { color: var(--muted); font-size: var(--text-label); }
+.remote-section-title svg { width: 18px; height: 18px; color: var(--muted); }
+.remote-section-title small { display: block; margin-top: 3px; color: var(--muted); font-size: var(--text-caption); }
+.remote-device-list { display: grid; gap: 6px; }
+.remote-device { display: flex; width: 100%; min-width: 0; align-items: center; gap: 4px; padding: 3px; border: 1px solid transparent; border-radius: var(--radius-sm); background: var(--raised); color: var(--text); }
+.remote-device:hover { background: var(--raised-hover); }
+.remote-device.selected { border-color: var(--accent-ring); background: var(--accent-soft); }
+.remote-device-main { display: flex; flex: 1; min-width: 0; align-items: center; gap: 10px; padding: 7px; border: 0; background: transparent; color: inherit; cursor: pointer; text-align: left; }
+.remote-device-main:focus-visible { outline: 2px solid var(--accent-ring); outline-offset: -1px; border-radius: var(--radius-xs); }
+.remote-online-dot { width: 9px; height: 9px; flex: 0 0 auto; border-radius: 50%; background: var(--faint); box-shadow: 0 0 0 3px color-mix(in srgb, var(--faint) 14%, transparent); }
+.remote-online-dot.online { background: var(--green); box-shadow: 0 0 0 3px color-mix(in srgb, var(--green) 14%, transparent); }
+.remote-device-copy { display: grid; flex: 1; min-width: 0; }
+.remote-device-copy strong, .remote-device-copy small { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.remote-device-copy small { margin-top: 2px; color: var(--muted); font-size: var(--text-caption); }
+.remote-revoke { display: grid; place-items: center; width: 30px; height: 30px; flex: 0 0 auto; border-radius: var(--radius-xs); color: var(--muted); }
+.remote-revoke:hover, .remote-revoke:focus-visible { color: var(--red); background: var(--red-soft); outline: none; }
+.remote-revoke svg { width: 15px; height: 15px; }
+.remote-empty { margin: 12px 0 0; color: var(--muted); font-size: var(--text-label); text-align: center; }
+.remote-empty--console { display: grid; min-height: 260px; place-items: center; margin: 0; }
+.remote-launch-fields { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 10px; }
+.remote-launch-fields label { min-width: 0; }
+.remote-launch-fields .select { width: 100%; }
+.remote-execution-map { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 8px; margin-top: 12px; }
+.remote-execution-map > span { display: grid; gap: 2px; min-width: 0; padding: 9px 10px; border: 1px solid var(--border-soft); border-radius: var(--radius-sm); background: var(--raised); color: var(--muted); font-size: var(--text-caption); }
+.remote-execution-map strong { overflow: hidden; color: var(--text); font-size: var(--text-control); text-overflow: ellipsis; white-space: nowrap; }
+.remote-runtime-reason { margin: 10px 0 0; color: var(--red); font-size: var(--text-caption); line-height: var(--leading-body); }
+.remote-launch-panel > .notice { margin-top: 10px; }
+.remote-start { width: 100%; margin-top: 12px; }
+.remote-console-panel { min-height: 440px; }
+.remote-status { padding: 4px 8px; border-radius: var(--radius-pill); background: var(--raised); color: var(--muted); font-size: var(--text-caption); font-weight: var(--weight-semibold); white-space: nowrap; }
+.remote-status--ready { color: var(--green); background: color-mix(in srgb, var(--green) 11%, transparent); }
+.remote-status--running, .remote-status--starting { color: var(--accent); background: var(--accent-soft); }
+.remote-status--failed { color: var(--red); background: var(--red-soft); }
+.remote-status--waiting_for_executor { color: var(--amber); background: color-mix(in srgb, var(--amber) 12%, transparent); }
+.remote-events { display: flex; min-height: 240px; max-height: min(48vh, 520px); flex-direction: column; gap: 8px; margin-top: 10px; padding: 10px; overflow: auto; border: 1px solid var(--border); border-radius: var(--radius-sm); background: var(--bg); content-visibility: auto; }
+.remote-console-panel > .notice { margin-top: 10px; }
+.remote-event { max-width: 88%; padding: 8px 10px; border-radius: var(--radius-sm); background: var(--raised); }
+.remote-event > span { color: var(--muted); font-size: var(--text-caption); font-weight: var(--weight-semibold); }
+.remote-event > p { margin: 3px 0 0; white-space: pre-wrap; overflow-wrap: anywhere; font-size: var(--text-control); line-height: var(--leading-body); }
+.remote-event--assistant { align-self: flex-start; border-left: 2px solid var(--accent); }
+.remote-event--tool { align-self: center; max-width: 96%; background: color-mix(in srgb, var(--accent) 6%, var(--raised)); }
+.remote-event--error { border-left: 2px solid var(--red); background: var(--red-soft); }
+.remote-composer { display: block; margin-top: 12px; }
+.remote-composer textarea { min-height: 92px; font-family: var(--font-sans); }
+.remote-console-actions { display: flex; justify-content: flex-end; gap: 8px; margin-top: 9px; }
+
+@media (max-width: 980px) {
+  .remote-workspace-grid { grid-template-columns: 1fr; }
+}
+@media (max-width: 620px) {
+  .remote-workspace-page .page-head { align-items: stretch; flex-direction: column; }
+  .remote-workspace-page .page-head > .btn { width: 100%; }
+  .remote-launch-fields { grid-template-columns: 1fr; }
+  .remote-execution-map { grid-template-columns: 1fr; }
+  .remote-console-actions { display: grid; grid-template-columns: 1fr 1fr; }
+  .remote-console-actions .btn { min-height: 44px; }
+  .remote-event { max-width: 100%; }
+  .remote-pairing-code { letter-spacing: .05em; }
+}
diff --git a/gui/src/styles.css b/gui/src/styles.css
index 1a51a2f40e..0899d77859 100644
--- a/gui/src/styles.css
+++ b/gui/src/styles.css
@@ -24,6 +24,7 @@
 @import "./styles-apikeys-workspace.css";
 @import "./styles-codex-set.css";
 @import "./styles-compatibility-matrix.css";
+@import "./styles-remote-workspace.css";
 
 :root {
   /* default: follow the OS; [data-theme] below pins color-scheme so light-dark() obeys it */
diff --git a/gui/tests/fr-localization.test.ts b/gui/tests/fr-localization.test.ts
index 89786fac49..14deb63f94 100644
--- a/gui/tests/fr-localization.test.ts
+++ b/gui/tests/fr-localization.test.ts
@@ -22,6 +22,10 @@ const INTENTIONAL_ENGLISH = new Set<TKey>([
   // than prose. Translating it would invent a difference the UI does not have.
   "models.aliasAuto",
   "common.github",
+  // Product names and ordinary French words whose correct spelling is identical to English.
+  "remote.pairingCommandWindows",
+  "remote.sessions",
+  "remote.prompt",
   // A filename and a product name. "AGENTS.md" is the literal file Codex reads,
   // and translating "Plugins" would invent a difference French does not have.
   "codexSet.layer.agents-md",
diff --git a/gui/tests/locale-parity.test.ts b/gui/tests/locale-parity.test.ts
index 3e05bb632f..456a38e4f8 100644
--- a/gui/tests/locale-parity.test.ts
+++ b/gui/tests/locale-parity.test.ts
@@ -109,6 +109,8 @@ const ZH_TW_KEEP_ENGLISH: ReadonlySet<string> = new Set([
   "codexAuth.codexApp",
   "codexAuth.creditNextBadge",
   "common.github",
+  // Windows PowerShell is a product name, not an untranslated prose placeholder.
+  "remote.pairingCommandWindows",
   "grok.title",
   // Integration tabs: client/product proper nouns kept in English
   "integrations.tab.codex",
diff --git a/gui/tests/remote-workspace.test.tsx b/gui/tests/remote-workspace.test.tsx
new file mode 100644
index 0000000000..6d409570fa
--- /dev/null
+++ b/gui/tests/remote-workspace.test.tsx
@@ -0,0 +1,373 @@
+import { afterEach, beforeEach, expect, test } from "bun:test";
+import { Window } from "happy-dom";
+import type { Root } from "react-dom/client";
+import { readPageFromHash } from "../src/app-routing";
+import { remoteWorkspacePairingCommands } from "../src/remote-workspace-command";
+
+const DEVICE_ID = "11111111-1111-4111-8111-111111111111";
+const ROOT_ID = "22222222-2222-4222-8222-222222222222";
+const SESSION_ID = "33333333-3333-4333-8333-333333333333";
+
+test("#remote resolves to the Remote Workspace page", () => {
+  expect(readPageFromHash("#remote")).toBe("remote");
+});
+
+test("pairing commands use native POSIX and PowerShell syntax", () => {
+  const commands = remoteWorkspacePairingCommands("ABCD-EFGH-JKLM", "https://hub.example.test/a'b");
+  expect(commands.posix).toContain(`'https://hub.example.test/a'"'"'b'`);
+  expect(commands.posix).toContain('--root "$PWD"');
+  expect(commands.powershell).toContain("'https://hub.example.test/a''b'");
+  expect(commands.powershell).toContain("--root (Get-Location).Path");
+  expect(commands.powershell).toContain("$LASTEXITCODE -eq 0");
+});
+
+let win: Window;
+let root: Root | null = null;
+let previous: Record<string, unknown>;
+const globals = ["window", "document", "navigator", "localStorage", "fetch", "IS_REACT_ACT_ENVIRONMENT"] as const;
+
+beforeEach(() => {
+  previous = Object.fromEntries(globals.map(key => [key, Reflect.get(globalThis, key)]));
+  win = new Window({ url: "http://localhost/#remote" });
+  Object.defineProperties(globalThis, {
+    window: { configurable: true, value: win },
+    document: { configurable: true, value: win.document },
+    navigator: { configurable: true, value: win.navigator },
+    localStorage: { configurable: true, value: win.localStorage },
+    IS_REACT_ACT_ENVIRONMENT: { configurable: true, value: true },
+  });
+});
+
+afterEach(async () => {
+  if (root) {
+    const current = root;
+    const { act } = await import("react");
+    await act(async () => current.unmount());
+    root = null;
+  }
+  for (const key of globals) Object.defineProperty(globalThis, key, { configurable: true, value: previous[key] });
+});
+
+test("pairs a computer and starts a Hub-owned session for its selected folder", async () => {
+  const calls: Array<{ url: string; method: string; body?: unknown }> = [];
+  let session: Record<string, unknown> | null = null;
+  let releaseLongPrompt: (() => void) | null = null;
+  const snapshot = () => ({
+    available: true,
+    devices: [{
+      id: DEVICE_ID,
+      name: "Computer 2",
+      platform: "win32-x64",
+      capabilities: ["workspace.read", "workspace.write"],
+      roots: [{ id: ROOT_ID, label: "Project" }],
+      online: true,
+      createdAt: "2026-01-01T00:00:00.000Z",
+      lastSeenAt: "2026-01-01T00:00:00.000Z",
+    }],
+    runtimes: {
+      codex: { available: true, version: "0.152.1" },
+      claude: { available: true, version: "2.1.223" },
+      pi: { available: true, version: "0.84.3" },
+    },
+    sessions: session ? [session] : [],
+  });
+  const response = (body: unknown, status = 200) => new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json" },
+  });
+  Object.defineProperty(globalThis, "fetch", {
+    configurable: true,
+    value: async (input: RequestInfo | URL, init: RequestInit = {}) => {
+      const url = String(input);
+      const method = init.method ?? "GET";
+      const body = typeof init.body === "string" ? JSON.parse(init.body) : undefined;
+      calls.push({ url, method, body });
+      if (url.endsWith("/api/remote-workspace") && method === "GET") return response(snapshot());
+      if (url.endsWith("/pairing") && method === "POST") {
+        return response({ code: "ABCD-EFGH-JKLM", expiresAt: "2026-01-01T00:10:00.000Z" }, 201);
+      }
+      if (url.endsWith("/sessions") && method === "POST") {
+        session = {
+          id: SESSION_ID,
+          profile: "codex",
+          accessMode: "read-only",
+          deviceId: DEVICE_ID,
+          deviceName: "Computer 2",
+          rootId: ROOT_ID,
+          rootLabel: "Project",
+          capabilities: ["workspace.read"],
+          tools: ["list_directory", "read_file"],
+          threadId: "thread-1",
+          resumable: true,
+          status: "ready",
+          createdAt: "2026-01-01T00:00:00.000Z",
+          updatedAt: "2026-01-01T00:00:00.000Z",
+          events: [],
+        };
+        return response(session, 201);
+      }
+      if (url.endsWith(`/${SESSION_ID}/prompt`) && method === "POST") {
+        const longPrompt = (body as { prompt?: string } | undefined)?.prompt === "Keep working";
+        if (longPrompt) {
+          await new Promise<void>(resolve => { releaseLongPrompt = resolve; });
+        }
+        const completed = {
+          ...session,
+          status: "ready",
+          events: [{ sequence: 1, at: "2026-01-01T00:00:01.000Z", type: "assistant", text: "Remote work completed" }],
+        };
+        // Simulate a response captured before DELETE completed. It can arrive late, but the
+        // server-side session remains stopped and the client must not resurrect its local copy.
+        if (!longPrompt) session = completed;
+        return response(completed);
+      }
+      if (url.endsWith(`/${SESSION_ID}`) && method === "DELETE") {
+        session = { ...session, status: "stopped" };
+        return response({ ok: true });
+      }
+      return response({ error: "unexpected request" }, 500);
+    },
+  });
+
+  const [{ act }, { createRoot }, { default: RemoteWorkspace }, { LanguageProvider }] = await Promise.all([
+    import("react"),
+    import("react-dom/client"),
+    import("../src/pages/RemoteWorkspace"),
+    import("../src/i18n/provider"),
+  ]);
+  const host = win.document.createElement("div") as unknown as HTMLElement;
+  win.document.body.appendChild(host as never);
+  await act(async () => {
+    root = createRoot(host);
+    root.render(<LanguageProvider><RemoteWorkspace apiBase="" hubOrigin="https://actual-hub.example.test" /></LanguageProvider>);
+    await new Promise(resolve => setTimeout(resolve, 20));
+  });
+  expect(host.textContent).toContain("Computer 2");
+  expect(host.textContent).toContain("Codex");
+
+  const button = (label: string) => [...host.querySelectorAll("button")].find(element => element.textContent?.includes(label)) as HTMLButtonElement;
+  await act(async () => { button("Read only").click(); });
+  expect(win.document.body.textContent).toContain("Edit files only");
+  await act(async () => { button("Create pairing code").click(); await new Promise(resolve => setTimeout(resolve, 10)); });
+  expect(host.textContent).toContain("ABCD-EFGH-JKLM");
+  expect(host.querySelector("pre")?.textContent).toContain("https://actual-hub.example.test");
+  expect(host.querySelector("pre")?.textContent).not.toContain("http://localhost");
+  expect(host.textContent).toContain("Linux / macOS terminal");
+  expect(host.textContent).toContain("Windows PowerShell");
+
+  await act(async () => { button("Start remote session").click(); await new Promise(resolve => setTimeout(resolve, 20)); });
+  expect(host.textContent).toContain("Remote session is ready");
+  const textarea = host.querySelector("textarea") as HTMLTextAreaElement;
+  await act(async () => {
+    Object.getOwnPropertyDescriptor(win.HTMLTextAreaElement.prototype, "value")!.set!.call(textarea, "Inspect the project");
+    textarea.dispatchEvent(new win.Event("input", { bubbles: true }) as never);
+  });
+  await act(async () => { button("Send").click(); await new Promise(resolve => setTimeout(resolve, 20)); });
+  expect(host.textContent).toContain("Remote work completed");
+  expect(calls.some(call => call.method === "POST" && call.body && (call.body as { deviceId?: string }).deviceId === DEVICE_ID)).toBe(true);
+  expect(calls.some(call => (call.body as { accessMode?: string } | undefined)?.accessMode === "read-only")).toBe(true);
+
+  // A long prompt request must not disable Stop. The DELETE runs concurrently, and a late
+  // prompt response must not replace the locally stopped state with a stale ready snapshot.
+  await act(async () => {
+    Object.getOwnPropertyDescriptor(win.HTMLTextAreaElement.prototype, "value")!.set!.call(textarea, "Keep working");
+    textarea.dispatchEvent(new win.Event("input", { bubbles: true }) as never);
+  });
+  await act(async () => { button("Send").click(); await new Promise(resolve => setTimeout(resolve, 10)); });
+  expect(button("Stop").disabled).toBe(false);
+  await act(async () => { button("Stop").click(); await new Promise(resolve => setTimeout(resolve, 10)); });
+  expect(calls.some(call => call.method === "DELETE" && call.url.endsWith(`/${SESSION_ID}`))).toBe(true);
+  await act(async () => { releaseLongPrompt?.(); await new Promise(resolve => setTimeout(resolve, 10)); });
+  expect(host.textContent).toContain("Stopped");
+});
+
+async function mountRemotePage(apiBase: string) {
+  const [{ act }, { createRoot }, { default: RemoteWorkspace }, { LanguageProvider }] = await Promise.all([
+    import("react"), import("react-dom/client"), import("../src/pages/RemoteWorkspace"), import("../src/i18n/provider"),
+  ]);
+  const host = win.document.createElement("div") as unknown as HTMLElement;
+  win.document.body.appendChild(host as never);
+  await act(async () => {
+    root = createRoot(host);
+    root.render(<LanguageProvider><RemoteWorkspace apiBase={apiBase} hubOrigin="https://hub.example.test" /></LanguageProvider>);
+  });
+  await act(async () => { await Promise.resolve(); });
+  return { host, act, button: (label: string) => [...host.querySelectorAll("button")].find(element => element.textContent?.includes(label)) as HTMLButtonElement };
+}
+
+const jsonResponse = (body: unknown, status = 200) => new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+function readySnapshot(status = "ready") {
+  return {
+    available: true,
+    devices: [{ id: DEVICE_ID, name: "Executor", platform: "win32", online: true, capabilities: ["workspace.read", "workspace.write"], roots: [{ id: ROOT_ID, label: "Project" }] }],
+    runtimes: { codex: { available: true }, claude: { available: false }, pi: { available: false } },
+    sessions: [{ id: SESSION_ID, profile: "codex", accessMode: "workspace", deviceId: DEVICE_ID, deviceName: "Executor", rootId: ROOT_ID, rootLabel: "Project", capabilities: ["workspace.read", "workspace.write"], tools: ["read_file", "write_file"], resumable: true, status, events: [] }],
+  };
+}
+
+test("disabled status presents explicit activation instructions", async () => {
+  Reflect.set(globalThis, "fetch", async () => jsonResponse({ available: false, devices: [], runtimes: {}, sessions: [] }));
+  const { host } = await mountRemotePage("/disabled-fixture");
+  expect(host.textContent).toContain("OCX_REMOTE_WORKSPACE_ENABLED=1");
+  expect(host.textContent).not.toContain("Create pairing code");
+});
+
+test("202 acceptance stays busy over an older ready poll and does not resubmit", async () => {
+  let sends = 0;
+  const stale = readySnapshot();
+  const accepted = { ...stale.sessions[0]!, status: "running", events: [{ sequence: 2, at: "2026-01-01T00:00:01Z", type: "status", text: "Turn accepted" }] };
+  Reflect.set(globalThis, "fetch", async (input: RequestInfo | URL) => {
+    if (String(input).endsWith("/prompt")) { sends++; return jsonResponse(accepted, 202); }
+    return jsonResponse(stale);
+  });
+  const { host, act, button } = await mountRemotePage("/accepted-fixture");
+  const textarea = host.querySelector("textarea") as HTMLTextAreaElement;
+  const type = async (value: string) => act(async () => {
+    Object.getOwnPropertyDescriptor(win.HTMLTextAreaElement.prototype, "value")!.set!.call(textarea, value);
+    textarea.dispatchEvent(new win.Event("input", { bubbles: true }) as never);
+  });
+  await type("first turn");
+  await act(async () => { button("Send").click(); });
+  expect(textarea.value).toBe("");
+  await type("next turn");
+  expect(button("Send").disabled).toBe(true);
+  expect(button("Stop").disabled).toBe(false);
+  expect(sends).toBe(1);
+});
+
+test("a pruned explicit selection still compares the fallback acceptance cursor", async () => {
+  let pruned = false;
+  const snapshot = readySnapshot();
+  const fallback = { ...snapshot.sessions[0]!, id: "44444444-4444-4444-8444-444444444444", rootLabel: "Fallback session" };
+  const old = { ...snapshot.sessions[0]!, status: "stopped", rootLabel: "Older session" };
+  const accepted = { ...fallback, status: "running", events: [{ sequence: 3, at: "2026-01-01T00:00:01Z", type: "status", text: "Turn accepted" }] };
+  Reflect.set(globalThis, "fetch", async (input: RequestInfo | URL) => {
+    if (String(input).endsWith("/prompt")) return jsonResponse(accepted, 202);
+    return jsonResponse({ ...snapshot, sessions: pruned ? [fallback] : [old, fallback] });
+  });
+  const { host, act, button } = await mountRemotePage("/pruned-selection-fixture");
+  await act(async () => { (host.querySelector('button[aria-label="Sessions"]') as HTMLButtonElement).click(); });
+  const option = [...win.document.querySelectorAll('[role="option"]')].find(element => element.textContent?.includes("Older session"));
+  expect(option).toBeDefined();
+  await act(async () => { (option as unknown as HTMLButtonElement).click(); });
+  pruned = true;
+  await act(async () => { button("Refresh").click(); });
+  const textarea = host.querySelector("textarea") as HTMLTextAreaElement;
+  const type = async (value: string) => act(async () => {
+    Object.getOwnPropertyDescriptor(win.HTMLTextAreaElement.prototype, "value")!.set!.call(textarea, value);
+    textarea.dispatchEvent(new win.Event("input", { bubbles: true }) as never);
+  });
+  await type("fallback turn");
+  await act(async () => { button("Send").click(); });
+  await type("next turn");
+  expect(button("Send").disabled).toBe(true);
+});
+
+test("lost acceptance keeps the draft and reports uncertainty without retrying", async () => {
+  let sends = 0;
+  Reflect.set(globalThis, "fetch", async (input: RequestInfo | URL) => {
+    if (String(input).endsWith("/prompt")) { sends++; throw new TypeError("connection lost"); }
+    return jsonResponse(readySnapshot());
+  });
+  const { host, act, button } = await mountRemotePage("/unknown-acceptance-fixture");
+  const textarea = host.querySelector("textarea") as HTMLTextAreaElement;
+  await act(async () => {
+    Object.getOwnPropertyDescriptor(win.HTMLTextAreaElement.prototype, "value")!.set!.call(textarea, "unconfirmed turn");
+    textarea.dispatchEvent(new win.Event("input", { bubbles: true }) as never);
+  });
+  await act(async () => { button("Send").click(); });
+  expect(textarea.value).toBe("unconfirmed turn");
+  expect(host.textContent).toContain("Submission status is unknown");
+  expect(sends).toBe(1);
+});
+
+test("a failed prompt preserves the newer draft and pairing never disables Stop", async () => {
+  let finishPrompt!: () => void;
+  let finishPairing!: () => void;
+  const heldPrompt = new Promise<void>(resolve => { finishPrompt = resolve; });
+  const heldPairing = new Promise<void>(resolve => { finishPairing = resolve; });
+  Reflect.set(globalThis, "fetch", async (input: RequestInfo | URL, init: RequestInit = {}) => {
+    const url = String(input);
+    if (url.endsWith("/prompt")) { await heldPrompt; return jsonResponse({ error: "prompt failed" }, 500); }
+    if (url.endsWith("/pairing")) { await heldPairing; return jsonResponse({ code: "ABCD-EFGH-JKLM", expiresAt: "2099-01-01T00:00:00Z" }); }
+    if (init.method === "DELETE") return jsonResponse({ ok: true });
+    return jsonResponse(readySnapshot());
+  });
+  const { host, act, button } = await mountRemotePage("/draft-fixture");
+  expect(host.textContent).toContain("Edit files only");
+  const textarea = host.querySelector("textarea") as HTMLTextAreaElement;
+  const type = async (value: string) => act(async () => {
+    Object.getOwnPropertyDescriptor(win.HTMLTextAreaElement.prototype, "value")!.set!.call(textarea, value);
+    textarea.dispatchEvent(new win.Event("input", { bubbles: true }) as never);
+  });
+  await type("first request");
+  await act(async () => { button("Send").click(); });
+  await type("new draft");
+  await act(async () => { button("Create pairing code").click(); });
+  expect(button("Stop").disabled).toBe(false);
+  await act(async () => { finishPrompt(); await heldPrompt; });
+  expect(textarea.value).toBe("new draft");
+  await act(async () => { finishPairing(); await heldPairing; });
+});
+
+test("running sessions reject keyboard submission and stale snapshots show an error", async () => {
+  let reads = 0;
+  let mutations = 0;
+  Reflect.set(globalThis, "fetch", async (_input: RequestInfo | URL, init: RequestInit = {}) => {
+    if (init.method === "POST") { mutations += 1; return jsonResponse({}); }
+    if (++reads > 1) throw new Error("Hub unavailable");
+    return jsonResponse(readySnapshot("running"));
+  });
+  const { host, act, button } = await mountRemotePage("/stale-fixture");
+  const textarea = host.querySelector("textarea") as HTMLTextAreaElement;
+  await act(async () => {
+    Object.getOwnPropertyDescriptor(win.HTMLTextAreaElement.prototype, "value")!.set!.call(textarea, "do not submit");
+    textarea.dispatchEvent(new win.Event("input", { bubbles: true }) as never);
+  });
+  await act(async () => { textarea.dispatchEvent(new win.KeyboardEvent("keydown", { key: "Enter", ctrlKey: true, bubbles: true }) as never); });
+  expect(mutations).toBe(0);
+  expect(textarea.value).toBe("do not submit");
+  await act(async () => { button("Refresh").click(); });
+  await act(async () => { await Promise.resolve(); });
+  expect(host.textContent).toContain("Could not load Remote Workspace");
+  expect(button("Stop").disabled).toBe(false);
+});
+
+test("Stop sends DELETE while an unrelated pairing request is held", async () => {
+  let finishPairing!: () => void;
+  const heldPairing = new Promise<void>(resolve => { finishPairing = resolve; });
+  let deleted = false;
+  Reflect.set(globalThis, "fetch", async (input: RequestInfo | URL, init: RequestInit = {}) => {
+    if (String(input).endsWith("/pairing")) { await heldPairing; return jsonResponse({ code: "ABCD-EFGH-JKLM", expiresAt: "2099-01-01T00:00:00Z" }); }
+    if (init.method === "DELETE") { deleted = true; return jsonResponse({ ok: true }); }
+    return jsonResponse(readySnapshot());
+  });
+  const { act, button } = await mountRemotePage("/stop-pairing-fixture");
+  await act(async () => { button("Create pairing code").click(); });
+  await act(async () => { button("Stop").click(); });
+  expect(deleted).toBe(true);
+  await act(async () => { finishPairing(); await heldPairing; });
+});
+
+test("stale ready sessions cannot submit through the keyboard", async () => {
+  let reads = 0;
+  let sent = false;
+  Reflect.set(globalThis, "fetch", async (_input: RequestInfo | URL, init: RequestInit = {}) => {
+    if (init.method === "POST") { sent = true; return jsonResponse({}); }
+    if (++reads > 1) throw new Error("offline");
+    return jsonResponse(readySnapshot());
+  });
+  const { host, act, button } = await mountRemotePage("/stale-ready-fixture");
+  const textarea = host.querySelector("textarea") as HTMLTextAreaElement;
+  await act(async () => {
+    Object.getOwnPropertyDescriptor(win.HTMLTextAreaElement.prototype, "value")!.set!.call(textarea, "preserve this");
+    textarea.dispatchEvent(new win.Event("input", { bubbles: true }) as never);
+  });
+  expect(button("Send").disabled).toBe(false);
+  await act(async () => { button("Refresh").click(); });
+  await act(async () => { await Promise.resolve(); });
+  expect(button("Send").disabled).toBe(true);
+  await act(async () => { textarea.dispatchEvent(new win.KeyboardEvent("keydown", { key: "Enter", ctrlKey: true, bubbles: true }) as never); });
+  expect(sent).toBe(false);
+  expect(textarea.value).toBe("preserve this");
+});
diff --git a/gui/tests/sidebar-rows.test.ts b/gui/tests/sidebar-rows.test.ts
index 308c08e21e..fbc682632a 100644
--- a/gui/tests/sidebar-rows.test.ts
+++ b/gui/tests/sidebar-rows.test.ts
@@ -27,11 +27,11 @@ test("every row maps one-to-one onto a page", () => {
   const navBlock = src.slice(src.indexOf("const NAV: NavEntry[] = ["), src.indexOf("];", src.indexOf("const NAV: NavEntry[] = [")));
   const ids = [...navBlock.matchAll(/\{ id: "([^"]+)"/g)].map(m => m[1]);
 
-  // The exact nine, in order. A count alone would pass if a row were swapped for
+  // The exact rows, in order. A count alone would pass if a row were swapped for
   // another, and Routing folding into Models is precisely that kind of change.
   expect(ids).toEqual([
     "dashboard", "codex-set", "providers", "models", "subagents",
-    "logs", "usage", "storage", "integrations",
+    "logs", "usage", "storage", "remote", "integrations",
   ]);
   // No two rows share a page id, which is what made the correction helper necessary.
   expect(new Set(ids).size).toBe(ids.length);
diff --git a/scripts/test-layout/layout.json b/scripts/test-layout/layout.json
index d10e31e701..eab170160a 100644
--- a/scripts/test-layout/layout.json
+++ b/scripts/test-layout/layout.json
@@ -1063,6 +1063,9 @@
     "release-notes.test.ts": "ci-workflows",
     "release-version-line.test.ts": "ci-workflows",
     "remote-catalog.test.ts": "clients",
+    "remote-workspace-activation.test.ts": "clients",
+    "remote-workspace-management.test.ts": "clients",
+    "remote-workspace-server.test.ts": "clients",
     "remote-workspace-secret-store.test.ts": "clients",
     "remote-workspace-session-binding.test.ts": "clients",
     "remote-workspace-agent-wire.test.ts": "clients",
diff --git a/skills/ocx/references/01_management_surface.md b/skills/ocx/references/01_management_surface.md
index 87e0a1ca77..48e5347991 100644
--- a/skills/ocx/references/01_management_surface.md
+++ b/skills/ocx/references/01_management_surface.md
@@ -28,6 +28,20 @@ These answer in the CLI head and never reach the proxy, so they work with nothin
 
 Safe to run at any time; none of these change state.
 
+### `ocx remote-workspace status`
+
+Read local executor enrollment and available capabilities without printing credentials.
+
+Drives no management route.
+
+| Flag | Value | Meaning |
+|---|---|---|
+| `--json` | boolean | Emit the public local executor status. |
+
+JSON mode: `payload`.
+
+- Executor-local operation; Hub consent and session control stay in the dashboard.
+
 ### `ocx models price`
 
 Read the saved manual price for an exact provider/model selector.
@@ -373,6 +387,35 @@ JSON mode: `payload`.
 
 Each of these writes. Check the flags column before running one unattended.
 
+### `ocx remote-workspace pair`
+
+Enroll this executor with one Hub using a one-time code from stdin and locally approved roots.
+
+Drives no management route.
+
+| Flag | Value | Meaning |
+|---|---|---|
+| `--json` | boolean | Emit the public local executor status. |
+| `--pairing-code-stdin` | boolean | Read the one-time pairing code from stdin. |
+| `--root` | string | Approve an absolute workspace directory; repeatable. |
+| `--toolchain-root` | string | Approve a read-only toolchain directory; repeatable. |
+| `--executor-helper` | string | Select a reviewed native helper file. |
+| `--name` | string | Name this executor. |
+
+JSON mode: `payload`.
+
+- Executor-local operation; Hub consent and session control stay in the dashboard.
+
+### `ocx remote-workspace agent`
+
+Keep the paired executor connected to its Hub.
+
+Drives no management route.
+
+JSON mode: `none`.
+
+- Executor-local operation; Hub consent and session control stay in the dashboard.
+
 ### `ocx models set-price`
 
 Save four manual USD-per-1M-token rates, or restore automatic pricing for one model.
@@ -792,6 +835,6 @@ JSON mode: `payload`.
 
 ## Counts
 
-- declared capabilities: 42
-- of those, state-changing: 21
+- declared capabilities: 45
+- of those, state-changing: 23
 - head-resolved invocations: 2
diff --git a/src/cli/capabilities.ts b/src/cli/capabilities.ts
index 52481b4adf..ac3014cece 100644
--- a/src/cli/capabilities.ts
+++ b/src/cli/capabilities.ts
@@ -95,6 +95,85 @@ export const HEAD_CAPABILITIES: readonly HeadCapability[] = [
  * A capability must not name a route the command does not actually fetch.
  */
 export const CAPABILITIES: readonly Capability[] = [
+  {
+    "command": [
+      "remote-workspace",
+      "pair"
+    ],
+    "summary": "Enroll this executor with one Hub using a one-time code from stdin and locally approved roots.",
+    "routes": [],
+    "flags": [
+      {
+        "name": "--json",
+        "value": "boolean",
+        "summary": "Emit the public local executor status."
+      },
+      {
+        "name": "--pairing-code-stdin",
+        "value": "boolean",
+        "summary": "Read the one-time pairing code from stdin."
+      },
+      {
+        "name": "--root",
+        "value": "string",
+        "summary": "Approve an absolute workspace directory; repeatable."
+      },
+      {
+        "name": "--toolchain-root",
+        "value": "string",
+        "summary": "Approve a read-only toolchain directory; repeatable."
+      },
+      {
+        "name": "--executor-helper",
+        "value": "string",
+        "summary": "Select a reviewed native helper file."
+      },
+      {
+        "name": "--name",
+        "value": "string",
+        "summary": "Name this executor."
+      }
+    ],
+    "mutates": true,
+    "json": "payload",
+    "details": [
+      "Executor-local operation; Hub consent and session control stay in the dashboard."
+    ]
+  },
+  {
+    "command": [
+      "remote-workspace",
+      "agent"
+    ],
+    "summary": "Keep the paired executor connected to its Hub.",
+    "routes": [],
+    "flags": [],
+    "mutates": true,
+    "json": "none",
+    "details": [
+      "Executor-local operation; Hub consent and session control stay in the dashboard."
+    ]
+  },
+  {
+    "command": [
+      "remote-workspace",
+      "status"
+    ],
+    "summary": "Read local executor enrollment and available capabilities without printing credentials.",
+    "routes": [],
+    "flags": [
+      {
+        "name": "--json",
+        "value": "boolean",
+        "summary": "Emit the public local executor status."
+      }
+    ],
+    "mutates": false,
+    "json": "payload",
+    "details": [
+      "Executor-local operation; Hub consent and session control stay in the dashboard."
+    ]
+  },
   {
     command: ["models", "price"],
     summary: "Read the saved manual price for an exact provider/model selector.",
diff --git a/src/cli/dispatch.ts b/src/cli/dispatch.ts
index 0f0ce8cc47..203d2d63d5 100644
--- a/src/cli/dispatch.ts
+++ b/src/cli/dispatch.ts
@@ -482,6 +482,10 @@ const commandRunners: Record<string, CommandRunner> = {
     const { handleConnectCommand } = await import("./connect");
     return await handleConnectCommand(deps.args.slice(1));
   },
+  "remote-workspace": async deps => {
+    const { runRemoteWorkspaceCommand } = await import("./remote-workspace");
+    return await runRemoteWorkspaceCommand(deps.args.slice(1));
+  },
   disconnect: async deps => {
     const { handleDisconnectCommand } = await import("./connect");
     return await handleDisconnectCommand(deps.args.slice(1));
diff --git a/src/cli/help.ts b/src/cli/help.ts
index 8608e5789d..15f6ed711a 100644
--- a/src/cli/help.ts
+++ b/src/cli/help.ts
@@ -41,6 +41,7 @@ Usage:
   ocx tray <sub>              Windows status tray (install|start|stop|status|uninstall)
   ocx ensure                  Ensure the proxy is running and Codex config/cache are current
   ocx connect <url>           Connect this machine to a remote OpenCodex hub (credential via stdin)
+  ocx remote-workspace <sub>  Pair/run an OCX-only remote execution computer
   ocx disconnect              Restore local state and clear the hub connection
   ocx sync [--restart-codex]  Fetch models from providers and inject into Codex config
   ocx sync-cache [--restart-codex]
diff --git a/src/cli/registry.ts b/src/cli/registry.ts
index 91eab8723b..1883bb27f2 100644
--- a/src/cli/registry.ts
+++ b/src/cli/registry.ts
@@ -107,6 +107,17 @@ export const CLI_COMMANDS: CliCommandEntry[] = [
       "Credentials are accepted only through stdin; argv and environment credential forms are not supported.",
     ],
   },
+  {
+    name: "remote-workspace",
+    usage: "ocx remote-workspace <pair|agent|status>",
+    summary: "Pair this OCX-only computer with a hub and run its remote workspace executor.",
+    details: [
+      "Pair: ocx remote-workspace pair <hub-url> --pairing-code-stdin --root <absolute-path> [--toolchain-root <absolute-directory>] [--executor-helper <absolute-file>] [--name <device-name>]",
+      "Agent: ocx remote-workspace agent",
+      "Status: ocx remote-workspace status [--json]",
+      "Codex, Claude Code, Pi, provider logins, and API keys remain on the hub; only workspace tools execute here.",
+    ],
+  },
   {
     name: "disconnect",
     usage: "ocx disconnect [--keep-catalog] [--json]",
diff --git a/src/remote-control/workspace-activation.ts b/src/remote-control/workspace-activation.ts
new file mode 100644
index 0000000000..ab4426c8b9
--- /dev/null
+++ b/src/remote-control/workspace-activation.ts
@@ -0,0 +1,9 @@
+import type { OcxConfig } from "../types";
+
+/** Side-effect-free opt-in; never creates a store, probes a runtime, or opens a listener. */
+export function remoteWorkspaceEnabled(
+  config: Pick<OcxConfig, "runtimeRole">,
+  enabled = process.env.OCX_REMOTE_WORKSPACE_ENABLED,
+): boolean {
+  return config.runtimeRole === "hub" && enabled === "1";
+}
diff --git a/src/remote-control/workspace-sessions.ts b/src/remote-control/workspace-sessions.ts
index 3d8d9a79e9..e537c6d2e5 100644
--- a/src/remote-control/workspace-sessions.ts
+++ b/src/remote-control/workspace-sessions.ts
@@ -279,6 +279,9 @@ export class RemoteWorkspaceSessionFileStore implements RemoteWorkspaceSessionSt
 }
 
 export class RemoteWorkspaceSessionService {
+  private shuttingDown = false;
+  private readonly pendingCreates = new Set<Promise<RemoteWorkspaceSessionSummary>>();
+  private startupCleanupFailure: Error | null = null;
   private readonly sessions = new Map<string, LiveSession>();
   private readonly runtimeReservations = new Map<string, string>();
   private readonly runtimes = new Map<RemoteWorkspaceAgentProfile, RemoteWorkspaceRuntimeFactory>();
@@ -368,18 +371,32 @@ export class RemoteWorkspaceSessionService {
     return () => { this.runtimeReservations.delete(reservation); };
   }
 
-  async create(input: {
+  create(input: {
     profile: RemoteWorkspaceAgentProfile;
     deviceId: string;
     rootId: string;
     accessMode?: RemoteWorkspaceAccessMode;
   }): Promise<RemoteWorkspaceSessionSummary> {
+    const operation = this.createSession(input);
+    this.pendingCreates.add(operation);
+    void operation.then(() => this.pendingCreates.delete(operation), () => this.pendingCreates.delete(operation));
+    return operation;
+  }
+
+  private async createSession(input: {
+    profile: RemoteWorkspaceAgentProfile;
+    deviceId: string;
+    rootId: string;
+    accessMode?: RemoteWorkspaceAccessMode;
+  }): Promise<RemoteWorkspaceSessionSummary> {
+    if (this.shuttingDown) throw new Error("remote workspace hub is stopping");
     this.pruneRetainedSessions();
     const releaseRuntime = this.reserveRuntime(input.deviceId);
     try {
       const factory = this.runtimes.get(input.profile);
       if (!factory) throw new Error(`remote workspace ${input.profile} runtime is not installed on the hub`);
       const available = await factory.available();
+      if (this.shuttingDown) throw new Error("remote workspace hub is stopping");
       if (!available.available) throw new Error(available.reason ?? `remote workspace ${input.profile} runtime is unavailable`);
       const device = this.hub.listDevices().find(candidate => candidate.id === input.deviceId);
       if (!device) throw new Error("remote workspace device not found");
@@ -453,8 +470,8 @@ export class RemoteWorkspaceSessionService {
           coordinator,
           emit: (type, text) => this.emit(session, type, text),
         });
-        if (session.stopOperation) {
-          await handle.stop().catch(() => {});
+        if (session.stopOperation || this.shuttingDown) {
+          await this.stopLateRuntime(handle);
           throw new Error("remote workspace session was stopped while starting");
         }
         session.threadId = handle.threadId;
@@ -495,6 +512,16 @@ export class RemoteWorkspaceSessionService {
   }
 
   async prompt(sessionId: string, value: unknown): Promise<RemoteWorkspaceSessionSummary> {
+    const session = this.startPrompt(sessionId, value);
+    await session.operation;
+    return this.publicSession(session);
+  }
+
+  submitPrompt(sessionId: string, value: unknown): RemoteWorkspaceSessionSummary {
+    return this.publicSession(this.startPrompt(sessionId, value));
+  }
+
+  private startPrompt(sessionId: string, value: unknown): LiveSession {
     const prompt = boundedPrompt(value);
     const session = this.sessions.get(sessionId);
     if (!session || session.status === "stopped") throw new Error("remote workspace session is not ready");
@@ -506,6 +533,7 @@ export class RemoteWorkspaceSessionService {
     session.turnActive = true;
     const run = async () => {
       try {
+        this.status(session, "running", "Turn accepted");
         await this.ensureRemoteTransport(session);
         await this.ensureRuntime(session);
         if (session.stopOperation) throw new Error("remote workspace session is stopping");
@@ -527,8 +555,10 @@ export class RemoteWorkspaceSessionService {
       }
     };
     session.operation = run();
-    await session.operation;
-    return this.publicSession(session);
+    // Polling observes the stored terminal status; awaited callers and cleanup retain
+    // the original rejecting promise, with an observer attached before detachment.
+    void session.operation.catch(() => {});
+    return session;
   }
 
   async stop(sessionId: string): Promise<boolean> {
@@ -570,8 +600,9 @@ export class RemoteWorkspaceSessionService {
   }
 
   async shutdown(): Promise<void> {
+    this.shuttingDown = true;
     const active = [...this.sessions.values()].filter(session => session.status !== "stopped");
-    await Promise.all(active.map(async session => {
+    const results = await Promise.allSettled(active.map(async session => {
       if (session.stopOperation) {
         await session.stopOperation;
         return;
@@ -607,9 +638,21 @@ export class RemoteWorkspaceSessionService {
       })();
       await session.stopOperation;
     }));
+    await Promise.allSettled([...this.pendingCreates]);
+    if (this.startupCleanupFailure) throw this.startupCleanupFailure;
+    const failed = results.find(result => result.status === "rejected");
+    if (failed?.status === "rejected") throw failed.reason;
     this.persist();
   }
 
+  private async stopLateRuntime(handle: RemoteWorkspaceRuntimeHandle): Promise<void> {
+    try { await handle.stop(); }
+    catch (error) {
+      this.startupCleanupFailure = error instanceof Error ? error : new Error("remote workspace startup cleanup failed");
+      throw this.startupCleanupFailure;
+    }
+  }
+
   private status(session: LiveSession, status: RemoteWorkspaceSessionStatus, text: string): void {
     session.status = status;
     this.emit(session, status === "failed" ? "error" : "status", text);
@@ -665,7 +708,7 @@ export class RemoteWorkspaceSessionService {
     if (session.remoteTransport) session.remoteTransport.replace(transport);
     else session.remoteTransport = new SwitchableRemoteWorkspaceTransport(transport);
     session.closeTransport = () => connection.closeSession(session.id);
-    this.status(session, "ready", `${session.profile} reconnected to ${session.deviceName}/${session.rootLabel}`);
+    this.status(session, session.turnActive ? "running" : "ready", `${session.profile} reconnected to ${session.deviceName}/${session.rootLabel}`);
   }
 
   private async ensureRuntime(session: LiveSession): Promise<void> {
@@ -678,6 +721,7 @@ export class RemoteWorkspaceSessionService {
     const releaseRuntime = this.reserveRuntime(session.deviceId);
     try {
       const available = await factory.available();
+      if (this.shuttingDown) throw new Error("remote workspace hub is stopping");
       if (!available.available) throw new Error(available.reason ?? `remote workspace ${session.profile} runtime is unavailable`);
       const coordinator = new RemoteWorkspaceCoordinator(session.remoteTransport);
       const handle = await factory.start({
@@ -692,10 +736,10 @@ export class RemoteWorkspaceSessionService {
         coordinator,
         emit: (type, text) => this.emit(session, type, text),
       });
-      if (session.stopOperation) {
-        // The stopping operation waits for this resume before reclaiming its late handle.
+      if (this.shuttingDown || session.stopOperation) {
+        // Stop/shutdown awaits this resume and must observe any late-handle cleanup failure.
         session.handle = handle;
-        throw new Error("remote workspace session is stopping");
+        throw new Error("remote workspace session was stopped while resuming");
       }
       try {
         session.unregister = coordinator.register({
@@ -713,7 +757,7 @@ export class RemoteWorkspaceSessionService {
       }
       session.threadId = handle.threadId;
       session.handle = handle;
-      this.status(session, "ready", `${session.profile} resumed on ${session.deviceName}/${session.rootLabel}`);
+      this.status(session, session.turnActive ? "running" : "ready", `${session.profile} resumed on ${session.deviceName}/${session.rootLabel}`);
     } finally {
       releaseRuntime();
     }
diff --git a/src/server/index.ts b/src/server/index.ts
index 3e458a3fea..423ec4849d 100644
--- a/src/server/index.ts
+++ b/src/server/index.ts
@@ -1,3 +1,4 @@
+import { remoteWorkspaceEnabled } from "../remote-control/workspace-activation";
 import { markActivity } from "../lib/sidecar-tracker";
 import { knownModelIdsForProvider } from "../router";
 import {
@@ -255,6 +256,7 @@ const WEBSOCKET_IDLE_TIMEOUT_SECONDS = 0;
 // class could inject a header break or a control character into a response we control.
 const REMOTE_CATALOG_KEY_ID_PATTERN = /^[A-Za-z0-9._-]{1,64}$/;
 const GUI_PAIRING_EXCHANGE_BODY_LIMIT = 4 * 1024;
+const REMOTE_WORKSPACE_PAIRING_BODY_LIMIT = 32 * 1024;
 
 /**
  * Read at most `limit` bytes of a request body, or refuse.
@@ -878,7 +880,10 @@ export function startServer(port?: number, deps: StartServerDeps = {}): Server<W
    */
   function managementIngressRouteAllowed(url: URL, req: Request): boolean {
     const rawPath = url.pathname;
-    if (req.headers.get("upgrade")?.toLowerCase() === "websocket") return false;
+    if (req.headers.get("upgrade")?.toLowerCase() === "websocket") {
+      return remoteWorkspaceEnabled(config) && rawPath === "/remote-workspace/agent";
+    }
+    if (rawPath === "/remote-workspace/pair") return remoteWorkspaceEnabled(config) && req.method === "POST";
     if (rawPath === "/opencodex-session") return req.method === "GET" || req.method === "POST";
     if (rawPath.startsWith("/api/")) return true;
     if (req.method !== "GET" && req.method !== "HEAD") return false;
@@ -1074,6 +1079,24 @@ export function startServer(port?: number, deps: StartServerDeps = {}): Server<W
   }
   let backgroundLifecycle: ReturnType<typeof acquireServerBackgroundLifecycle> | null = null;
   let unregisterQuotaAutoRefresh: (() => void) | null = null;
+  let remoteWorkspaceStopping = false;
+  let remoteWorkspaceShutdown: (() => Promise<void>) | undefined;
+  const managementApiDeps: ManagementApiDeps = {
+    ...deps.managementApi,
+    remoteWorkspaceStopping: () => remoteWorkspaceStopping,
+    onRemoteWorkspaceShutdown: shutdown => { remoteWorkspaceShutdown = shutdown; },
+  };
+  let workspaceRuntimeFlight: Promise<typeof import("../remote-control/workspace-runtime")> | undefined;
+  const loadRemoteWorkspaceRuntime = () => {
+    workspaceRuntimeFlight ??= import("../remote-control/workspace-runtime");
+    remoteWorkspaceShutdown = async () => {
+      const runtime = await workspaceRuntimeFlight!;
+      const sessions = deps.managementApi?.remoteWorkspaceSessions ?? runtime.initializedRemoteWorkspaceSessionsForConfig(config);
+      const hub = deps.managementApi?.remoteWorkspaceHub ?? runtime.initializedRemoteWorkspaceHubForConfig(config);
+      try { await sessions?.shutdown(); } finally { hub?.closeAllConnections(); }
+    };
+    return workspaceRuntimeFlight;
+  };
   try {
     backgroundLifecycle = acquireServerBackgroundLifecycle(applyPolicy);
     unregisterQuotaAutoRefresh = (deps.registerCodexQuotaAutoRefreshWorker
@@ -1174,6 +1197,133 @@ export function startServer(port?: number, deps: StartServerDeps = {}): Server<W
         });
       }
 
+      // An OCX-only executor exchanges one short-lived pairing code for a device-scoped
+      // token. This is intentionally outside /api: management auth belongs to the browser
+      // that created the grant, while the new device owns only that one-time code.
+      if (url.pathname === "/remote-workspace/pair" && req.method === "POST") {
+        if (!remoteWorkspaceEnabled(config)) {
+          return Response.json({ error: "Remote Workspace is not enabled on this OpenCodex instance." }, { status: 404 });
+        }
+        // Browser JavaScript must use the authenticated dashboard route. Refusing Origin-bearing
+        // requests leaves this exchange to an explicit OCX device process and avoids turning a
+        // copied pairing code into a cross-site enrollment action.
+        if (req.headers.get("origin") !== null) {
+          return Response.json({ error: "Remote Workspace device pairing does not accept browser-origin requests." }, {
+            status: 403,
+            headers: { "cache-control": "no-store" },
+          });
+        }
+        const [{ remoteWorkspaceHubForConfig }, { RemoteWorkspacePairingRateLimitError }] = await Promise.all([
+          loadRemoteWorkspaceRuntime(),
+          import("../remote-control/workspace-hub"),
+        ]);
+        if (remoteWorkspaceStopping) return Response.json({ error: "Remote Workspace is stopping." }, { status: 503 });
+        const hub = deps.managementApi?.remoteWorkspaceHub ?? remoteWorkspaceHubForConfig(config);
+        // A loopback socket alone cannot prove that Tailscale Serve supplied its identity header:
+        // another local process can connect directly and forge it. Pairing therefore uses only the
+        // kernel-observed peer on every listener; proxied management users intentionally share the
+        // loopback bucket rather than gaining a header-rotation bypass.
+        const peer = requestServer.requestIP(req)?.address ?? "unknown";
+        const pairingSource = `${ingress}:${peer}`;
+        const rateLimitResponse = (error: unknown): Response | null => {
+          if (!(error instanceof RemoteWorkspacePairingRateLimitError)) return null;
+          return Response.json({ error: "Remote Workspace pairing is temporarily rate limited." }, {
+            status: 429,
+            headers: {
+              "cache-control": "no-store",
+              "retry-after": String(error.retryAfterSeconds),
+            },
+          });
+        };
+        try {
+          // Check the existing source block before reading or parsing an attacker-controlled body.
+          // pairDevice checks again after the await and records only code-shaped authentication
+          // failures, so malformed JSON cannot allocate one limiter entry per request.
+          hub.assertPairingSourceAllowed(pairingSource);
+        } catch (error) {
+          const limited = rateLimitResponse(error);
+          if (limited) return limited;
+          throw error;
+        }
+        const declaredLength = Number(req.headers.get("content-length") ?? "0");
+        if (!Number.isFinite(declaredLength) || declaredLength > REMOTE_WORKSPACE_PAIRING_BODY_LIMIT) {
+          return Response.json({ error: "Remote Workspace pairing body is too large." }, { status: 413 });
+        }
+        const text = await readBoundedRequestText(req, REMOTE_WORKSPACE_PAIRING_BODY_LIMIT);
+        if (text === null) return Response.json({ error: "Remote Workspace pairing body is too large." }, { status: 413 });
+        if (remoteWorkspaceStopping) return Response.json({ error: "Remote Workspace is stopping." }, { status: 503 });
+        let body: unknown;
+        try { body = JSON.parse(text); }
+        catch { return Response.json({ error: "Invalid Remote Workspace pairing request." }, { status: 400 }); }
+        if (!body || typeof body !== "object" || Array.isArray(body)) {
+          return Response.json({ error: "Invalid Remote Workspace pairing request." }, { status: 400 });
+        }
+        const record = body as Record<string, unknown>;
+        const required = ["code", "name", "platform", "publicKey", "roots"];
+        const allowed = new Set([...required, "capabilities"]);
+        if (required.some(key => !Object.hasOwn(record, key))
+          || Object.keys(record).some(key => !allowed.has(key))) {
+          return Response.json({ error: "Invalid Remote Workspace pairing request." }, { status: 400 });
+        }
+        try {
+          const paired = hub.pairDevice(record, pairingSource);
+          return Response.json(paired, { status: 201, headers: { "cache-control": "no-store" } });
+        } catch (error) {
+          const limited = rateLimitResponse(error);
+          if (limited) return limited;
+          const message = error instanceof Error ? error.message : "Remote Workspace pairing failed.";
+          const conflict = /already in use|limit reached/i.test(message);
+          return Response.json({ error: message }, {
+            status: conflict ? 409 : 401,
+            headers: { "cache-control": "no-store" },
+          });
+        }
+      }
+
+      // Each executor holds one device-scoped bearer and opens one outbound WSS. The token is
+      // authenticated only at upgrade and never enters ws.data; subsequent frames are bound to
+      // the device identity and per-session signed E2EE handshake.
+      if (url.pathname === "/remote-workspace/agent" && req.headers.get("upgrade")?.toLowerCase() === "websocket") {
+        if (!remoteWorkspaceEnabled(config) || req.headers.get("origin") !== null) {
+          return Response.json({ error: "Remote Workspace agent upgrade refused." }, { status: 403 });
+        }
+        const authorization = req.headers.get("authorization") ?? "";
+        const match = /^Bearer (ocxrw_[A-Za-z0-9_-]{43})$/.exec(authorization);
+        if (!match) return Response.json({ error: "Remote Workspace device authentication required." }, { status: 401 });
+        const { remoteWorkspaceHubForConfig } = await loadRemoteWorkspaceRuntime();
+        const { RemoteWorkspaceHubAgentConnection } = await import("../remote-control/workspace-agent-connection");
+        if (remoteWorkspaceStopping) return Response.json({ error: "Remote Workspace is stopping." }, { status: 503 });
+        const hub = deps.managementApi?.remoteWorkspaceHub ?? remoteWorkspaceHubForConfig(config);
+        const device = hub.authenticateDeviceToken(match[1]!);
+        if (!device) return Response.json({ error: "Remote Workspace device authentication failed." }, { status: 401 });
+        const upgraded = requestServer.upgrade(req, {
+          data: {
+            kind: "remote-workspace-agent",
+            remoteWorkspaceOpen: socket => {
+              const connection = new RemoteWorkspaceHubAgentConnection({
+                deviceId: device.id,
+                devicePublicKey: device.publicKey,
+                hubIdentity: hub.identity(),
+                capabilities: device.capabilities,
+                onCapabilities: capabilities => hub.updateDeviceCapabilities(device.id, capabilities),
+                socket: {
+                  send: value => {
+                    if (socket.send(value) === 0) throw new Error("remote workspace socket send dropped");
+                  },
+                  close: (code, reason) => socket.close(code, reason),
+                },
+              });
+              hub.attachConnection(device.id, connection);
+              socket.data.remoteWorkspaceClose = () => hub.detachConnection(device.id, connection);
+              return connection;
+            },
+          } satisfies WsData,
+        });
+        return upgraded
+          ? undefined as unknown as Response
+          : Response.json({ error: "Remote Workspace WebSocket upgrade failed." }, { status: 426 });
+      }
+
       // Responses WebSocket (phase 120.2). Codex upgrades the same /v1/responses path; auth is
       // handshake-time only, so capture inbound headers and thread them into the pipeline.
       if (url.pathname === "/v1/responses" && req.headers.get("upgrade")?.toLowerCase() === "websocket") {
@@ -1306,7 +1456,7 @@ export function startServer(port?: number, deps: StartServerDeps = {}): Server<W
             }), req, config);
           }
         }
-        const mgmtResponse = await handleManagementAPI(req, url, config, deps.managementApi, principal, managementSessionControl);
+        const mgmtResponse = await handleManagementAPI(req, url, config, managementApiDeps, principal, managementSessionControl);
         if (mgmtResponse) return withManagementCors(mgmtResponse, req, config);
         return withManagementCors(formatErrorResponse(404, "not_found", `Unknown endpoint: ${req.method} ${url.pathname}`), req, config);
       }
@@ -2327,6 +2477,19 @@ export function startServer(port?: number, deps: StartServerDeps = {}): Server<W
       // Text frames. response.processed is a no-op ack. close() aborts the upstream (RC2 parity).
       // Live sideband sockets (kind=live-sideband) are a transparent bidirectional relay instead.
       open(ws: ServerWebSocket<WsData>) {
+        if (ws.data.kind === "remote-workspace-agent") {
+          const open = ws.data.remoteWorkspaceOpen;
+          if (!open) {
+            ws.close(1011, "remote workspace connection unavailable");
+            return;
+          }
+          try {
+            ws.data.remoteWorkspaceConnection = open(ws);
+          } catch {
+            ws.close(1011, "remote workspace connection failed");
+          }
+          return;
+        }
         if (ws.data.kind === "live-sideband") {
           if (!ws.data.liveTurnAdmissionLease) {
             closeLiveSideband(ws, 1013, "server busy");
@@ -2343,6 +2506,14 @@ export function startServer(port?: number, deps: StartServerDeps = {}): Server<W
         registerCodexWebSocket(ws);
       },
       message(ws: ServerWebSocket<WsData>, raw: string | Buffer) {
+        if (ws.data.kind === "remote-workspace-agent") {
+          try {
+            ws.data.remoteWorkspaceConnection?.receive(raw);
+          } catch {
+            ws.close(1008, "remote workspace protocol error");
+          }
+          return;
+        }
         if (ws.data.kind === "live-sideband") {
           if (ws.data.liveClosing) return;
           const rawBytes = webSocketFrameBytes(raw);
@@ -2521,6 +2692,10 @@ export function startServer(port?: number, deps: StartServerDeps = {}): Server<W
         })();
       },
       close(ws: ServerWebSocket<WsData>) {
+        if (ws.data.kind === "remote-workspace-agent") {
+          ws.data.remoteWorkspaceClose?.();
+          return;
+        }
         if (ws.data.kind === "live-sideband") {
           closeLiveSideband(ws);
           return;
@@ -2591,6 +2766,7 @@ export function startServer(port?: number, deps: StartServerDeps = {}): Server<W
   Object.defineProperty(server, "stop", {
     configurable: true,
     value: async (closeActiveConnections?: boolean): Promise<void> => {
+      remoteWorkspaceStopping = true;
       // The orchestration lives in `runListenerShutdown` so its two competing properties —
       // cleanup completes, failure propagates — are testable without a live socket.
       await runListenerShutdown(
@@ -2602,6 +2778,7 @@ export function startServer(port?: number, deps: StartServerDeps = {}): Server<W
           ...(managementIngressRef
             ? [() => managementIngressRef.stop(closeActiveConnections)]
             : []),
+          async () => { await remoteWorkspaceShutdown?.(); },
           async () => {
             try {
               userCostOverlayReconciler?.stop();
@@ -2658,7 +2835,7 @@ export function startServer(port?: number, deps: StartServerDeps = {}): Server<W
   if (managementIngressServer) {
     const managementPort = managementIngressServer.port ?? managementIngressPort;
     console.log(`🔒 Hub management ingress active on http://127.0.0.1:${managementPort}`);
-    console.log(`   GUI and /api/* only; data, health, readiness, and WebSockets are disabled.`);
+    console.log(`   GUI and /api/*; opted-in Remote Workspace pairing/agent only; data, health, and readiness are disabled.`);
   }
 
   // Prime pool-account quota in the background so the rotation engine has real
diff --git a/src/server/lifecycle.ts b/src/server/lifecycle.ts
index bf5d4ee292..c3ab23e641 100644
--- a/src/server/lifecycle.ts
+++ b/src/server/lifecycle.ts
@@ -365,12 +365,11 @@ export async function runListenerShutdown(
   always: () => Promise<void>,
 ): Promise<void> {
   const failures: unknown[] = [];
-  for (const step of steps) {
-    try {
-      await step();
-    } catch (error) {
-      failures.push(error);
-    }
+  // Close admission and start connection-owner cleanup before waiting for any drain.
+  // A graceful listener stop can itself depend on a later owner closing its sockets.
+  const results = await Promise.allSettled(steps.map(async step => { await step(); }));
+  for (const result of results) {
+    if (result.status === "rejected") failures.push(result.reason);
   }
   try {
     await always();
diff --git a/src/server/management-api.ts b/src/server/management-api.ts
index 3eb0d775fa..4dc2a16c77 100644
--- a/src/server/management-api.ts
+++ b/src/server/management-api.ts
@@ -1,3 +1,4 @@
+import { remoteWorkspaceEnabled } from "../remote-control/workspace-activation";
 import { randomUUID } from "node:crypto";
 import { readFileSync } from "node:fs";
 import type { CatalogModel } from "../codex/catalog";
@@ -149,6 +150,20 @@ async function handleGrokCouponRoutesOnDemand(ctx: ManagementContext): Promise<R
   return handleGrokCouponRoutes(ctx);
 }
 
+async function handleRemoteWorkspaceRoutesOnDemand(ctx: ManagementContext): Promise<Response | null> {
+  if (!pathInManagementNamespace(ctx.url.pathname, "/api/remote-workspace")) return null;
+  if (!remoteWorkspaceEnabled(ctx.config)) {
+    return Response.json({ available: false, reason: "Remote Workspace requires Hub mode and OCX_REMOTE_WORKSPACE_ENABLED=1.", devices: [], runtimes: {}, sessions: [] }, {
+      status: ctx.req.method === "GET" ? 200 : 404, headers: { "cache-control": "no-store" },
+    });
+  }
+  if (ctx.req.method !== "GET" && ctx.principal !== "gui-session") {
+    return Response.json({ error: "A dashboard session is required for Remote Workspace changes." }, { status: 403 });
+  }
+  const { handleRemoteWorkspaceRoutes } = await import("./management/remote-workspace-routes");
+  return handleRemoteWorkspaceRoutes(ctx);
+}
+
 export async function handleManagementAPI(
   req: Request,
   url: URL,
@@ -242,6 +257,7 @@ export async function handleManagementAPI(
   let routed: Response | null;
   try {
     routed = handleSessionRoutes(ctx)
+    ??     (await handleRemoteWorkspaceRoutesOnDemand(ctx))
     ??     (await handleConfigRoutes(ctx))
     ??     (await handleStorageLogGuardRoutes(ctx))
     ??     (await handleLogsUsageRoutes(ctx))
diff --git a/src/server/management/context.ts b/src/server/management/context.ts
index f516dc00d9..cb0e1185f8 100644
--- a/src/server/management/context.ts
+++ b/src/server/management/context.ts
@@ -20,7 +20,22 @@ import type {
   readCodexAppServerState,
 } from "../../codex/app-server-restart-service";
 
+import type { RemoteWorkspaceHub } from "../../remote-control/workspace-hub";
+import type { RemoteWorkspaceSessionService } from "../../remote-control/workspace-sessions";
+
+export type RemoteWorkspaceHubApi = Pick<RemoteWorkspaceHub,
+  "identity" | "createPairingGrant" | "assertPairingSourceAllowed" | "pairDevice"
+  | "authenticateDeviceToken" | "attachConnection" | "updateDeviceCapabilities"
+  | "detachConnection" | "listDevices" | "revokeDevice" | "closeAllConnections">;
+export type RemoteWorkspaceSessionsApi = Pick<RemoteWorkspaceSessionService,
+  "availability" | "list" | "create" | "prompt" | "submitPrompt" | "stop" | "shutdown">;
+
 export interface ManagementApiDeps {
+  remoteWorkspaceHub?: RemoteWorkspaceHubApi;
+  remoteWorkspaceSessions?: RemoteWorkspaceSessionsApi;
+  /** The listener retains and awaits teardown only after this optional subsystem activates. */
+  remoteWorkspaceStopping?: () => boolean;
+  onRemoteWorkspaceShutdown?: (shutdown: () => Promise<void>) => void;
   /** Isolates automatic owned-client writes in route tests. */
   refreshOwnedCatalogIntegrations?: typeof refreshOwnedCatalogIntegrations;
   /** Platform seam for capability projections; does not alter host-level startup behavior. */
diff --git a/src/server/management/remote-workspace-routes.ts b/src/server/management/remote-workspace-routes.ts
new file mode 100644
index 0000000000..f94ab3dda1
--- /dev/null
+++ b/src/server/management/remote-workspace-routes.ts
@@ -0,0 +1,140 @@
+import { readManagementJsonBody, rethrowManagementBodyTooLarge } from "./body";
+import { remoteWorkspaceEnabled } from "../../remote-control/workspace-activation";
+import type { ManagementContext } from "./context";
+import { isRemoteWorkspaceAgentProfile } from "../../remote-control/workspace-agent-protocol";
+
+const REMOTE_WORKSPACE_PREFIX = "/api/remote-workspace";
+
+function response(body: unknown, status = 200): Response {
+  return Response.json(body, { status, headers: { "cache-control": "no-store" } });
+}
+
+function sessionOnly(ctx: ManagementContext): Response | null {
+  return ctx.principal === "gui-session"
+    ? null
+    : response({ error: "A dashboard session is required for Remote Workspace changes." }, 403);
+}
+
+async function jsonObject(req: Request): Promise<Record<string, unknown>> {
+  let value: unknown;
+  try { value = await readManagementJsonBody(req); } catch (error) { rethrowManagementBodyTooLarge(error); throw new Error("Remote Workspace request body must be JSON."); }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Remote Workspace request body must be an object.");
+  }
+  return value as Record<string, unknown>;
+}
+
+function exactBodyKeys(
+  body: Record<string, unknown>,
+  required: readonly string[],
+  optional: readonly string[] = [],
+): void {
+  const allowed = new Set([...required, ...optional]);
+  if (required.some(key => !Object.hasOwn(body, key))
+    || Object.keys(body).some(key => !allowed.has(key))) {
+    throw new Error("Remote Workspace request body contains invalid fields.");
+  }
+}
+
+export async function handleRemoteWorkspaceRoutes(ctx: ManagementContext): Promise<Response | null> {
+  const { req, url, config } = ctx;
+  if (!url.pathname.startsWith(REMOTE_WORKSPACE_PREFIX)) return null;
+  if (url.pathname.length > REMOTE_WORKSPACE_PREFIX.length
+    && url.pathname[REMOTE_WORKSPACE_PREFIX.length] !== "/") return null;
+  if (!remoteWorkspaceEnabled(config)) {
+    return response({ available: false, reason: "Remote Workspace requires this OpenCodex instance to run as a hub." }, 409);
+  }
+  if (req.method !== "GET") {
+    const denied = sessionOnly(ctx);
+    if (denied) return denied;
+  }
+  if (ctx.deps.remoteWorkspaceStopping?.()) return response({ error: "Remote Workspace is stopping." }, 503);
+  const runtime = await import("../../remote-control/workspace-runtime");
+  if (ctx.deps.remoteWorkspaceStopping?.()) return response({ error: "Remote Workspace is stopping." }, 503);
+  const hub = ctx.deps.remoteWorkspaceHub ?? runtime.remoteWorkspaceHubForConfig(config);
+  const sessions = ctx.deps.remoteWorkspaceSessions ?? runtime.remoteWorkspaceSessionsForConfig(config);
+  ctx.deps.onRemoteWorkspaceShutdown?.(async () => {
+    const sessions = ctx.deps.remoteWorkspaceSessions ?? runtime.initializedRemoteWorkspaceSessionsForConfig(config);
+    const hub = ctx.deps.remoteWorkspaceHub ?? runtime.initializedRemoteWorkspaceHubForConfig(config);
+    try { await sessions?.shutdown(); } finally { hub?.closeAllConnections(); }
+  });
+  if (url.pathname === "/api/remote-workspace" && req.method === "GET") {
+    return response({
+      available: true,
+      devices: hub.listDevices(),
+      runtimes: await sessions.availability(),
+      sessions: sessions.list(),
+    });
+  }
+  if (url.pathname === "/api/remote-workspace/pairing" && req.method === "POST") {
+    const denied = sessionOnly(ctx);
+    if (denied) return denied;
+    try {
+      return response(hub.createPairingGrant(), 201);
+    } catch (error) {
+      rethrowManagementBodyTooLarge(error);
+      return response({ error: error instanceof Error ? error.message : "Remote Workspace pairing failed." }, 429);
+    }
+  }
+  const match = /^\/api\/remote-workspace\/devices\/([0-9a-f-]+)$/i.exec(url.pathname);
+  if (match && req.method === "DELETE") {
+    const denied = sessionOnly(ctx);
+    if (denied) return denied;
+    if (!hub.revokeDevice(match[1]!)) return response({ error: "Remote Workspace device not found." }, 404);
+    await Promise.all(sessions.list()
+      .filter(session => session.deviceId === match[1] && session.status !== "stopped")
+      .map(session => sessions.stop(session.id)));
+    return response({ ok: true });
+  }
+  if (url.pathname === "/api/remote-workspace/sessions" && req.method === "GET") {
+    return response({ sessions: sessions.list() });
+  }
+  if (url.pathname === "/api/remote-workspace/runtimes" && req.method === "GET") {
+    return response({ runtimes: await sessions.availability() });
+  }
+  if (url.pathname === "/api/remote-workspace/sessions" && req.method === "POST") {
+    const denied = sessionOnly(ctx);
+    if (denied) return denied;
+    try {
+      const body = await jsonObject(req);
+      exactBodyKeys(body, ["profile", "deviceId", "rootId"], ["accessMode"]);
+      if (!isRemoteWorkspaceAgentProfile(body.profile)
+        || typeof body.deviceId !== "string"
+        || typeof body.rootId !== "string"
+        || (body.accessMode !== undefined && body.accessMode !== "read-only" && body.accessMode !== "workspace")) {
+        throw new Error("profile, deviceId, rootId, and a valid accessMode are required.");
+      }
+      return response(await sessions.create({
+        profile: body.profile,
+        deviceId: body.deviceId,
+        rootId: body.rootId,
+        accessMode: body.accessMode === "workspace" ? "workspace" : "read-only",
+      }), 201);
+    } catch (error) {
+      rethrowManagementBodyTooLarge(error);
+      return response({ error: error instanceof Error ? error.message : "Remote Workspace session failed." }, 409);
+    }
+  }
+  const promptMatch = /^\/api\/remote-workspace\/sessions\/([0-9a-f-]+)\/prompt$/i.exec(url.pathname);
+  if (promptMatch && req.method === "POST") {
+    const denied = sessionOnly(ctx);
+    if (denied) return denied;
+    try {
+      const body = await jsonObject(req);
+      exactBodyKeys(body, ["prompt"]);
+      return response(sessions.submitPrompt(promptMatch[1]!, body.prompt), 202);
+    } catch (error) {
+      rethrowManagementBodyTooLarge(error);
+      return response({ error: error instanceof Error ? error.message : "Remote Workspace turn failed." }, 409);
+    }
+  }
+  const sessionMatch = /^\/api\/remote-workspace\/sessions\/([0-9a-f-]+)$/i.exec(url.pathname);
+  if (sessionMatch && req.method === "DELETE") {
+    const denied = sessionOnly(ctx);
+    if (denied) return denied;
+    return await sessions.stop(sessionMatch[1]!)
+      ? response({ ok: true })
+      : response({ error: "Remote Workspace session not found." }, 404);
+  }
+  return response({ error: "Unknown Remote Workspace operation." }, 404);
+}
diff --git a/src/server/management/route-registry.ts b/src/server/management/route-registry.ts
index 105cdb2ba6..32996340c0 100644
--- a/src/server/management/route-registry.ts
+++ b/src/server/management/route-registry.ts
@@ -327,6 +327,15 @@ export const MANAGEMENT_ROUTES: readonly ManagementRoute[] = [
   { method: "POST", path: "/api/storage/codex-logs/protect", module: "server/management/storage-log-guard-routes", mutates: true },
   { method: "POST", path: "/api/storage/codex-logs/repair", module: "server/management/storage-log-guard-routes", mutates: true },
   { method: "POST", path: "/api/storage/codex-logs/unprotect", module: "server/management/storage-log-guard-routes", mutates: true },
+  // server/management/remote-workspace-routes
+  { method: "GET", path: "/api/remote-workspace", module: "server/management/remote-workspace-routes", mutates: false, exempt: { reason: "deferred-verb", why: "The first Remote Workspace slice exposes Hub status through the authenticated dashboard; a distinct CLI Hub-status verb is still owed and must not be confused with the Executor-local status command.", owner: "remote-workspace-cli-followup", ownerDoc: "docs-site/src/content/docs/reference/management-api.md" } },
+  { method: "GET", path: "/api/remote-workspace/runtimes", module: "server/management/remote-workspace-routes", mutates: false, exempt: { reason: "deferred-verb", why: "The first Remote Workspace slice exposes Hub runtime availability through the authenticated dashboard; a distinct CLI Hub-status verb is still owed.", owner: "remote-workspace-cli-followup", ownerDoc: "docs-site/src/content/docs/reference/management-api.md" } },
+  { method: "GET", path: "/api/remote-workspace/sessions", module: "server/management/remote-workspace-routes", mutates: false, exempt: { reason: "deferred-verb", why: "The first Remote Workspace slice exposes Hub session snapshots through the authenticated dashboard; a distinct CLI Hub-status verb is still owed.", owner: "remote-workspace-cli-followup", ownerDoc: "docs-site/src/content/docs/reference/management-api.md" } },
+  { method: "POST", path: "/api/remote-workspace/pairing", module: "server/management/remote-workspace-routes", mutates: true, exempt: { reason: "session-only", why: "Creating a device enrollment grant authorizes another computer, so only a dashboard consent session may request one." } },
+  { method: "POST", path: "/api/remote-workspace/sessions", module: "server/management/remote-workspace-routes", mutates: true, exempt: { reason: "session-only", why: "Starting a Hub-authenticated model session against a remote computer requires an interactive dashboard consent session." } },
+  { method: "POST", path: "/api/remote-workspace/sessions/{id}/prompt", module: "server/management/remote-workspace-routes", mutates: true, mechanism: "regex", exempt: { reason: "session-only", why: "A prompt can execute tools on the selected remote computer and therefore requires an interactive dashboard consent session." } },
+  { method: "DELETE", path: "/api/remote-workspace/devices/{id}", module: "server/management/remote-workspace-routes", mutates: true, mechanism: "regex", exempt: { reason: "session-only", why: "Revoking a Remote Workspace computer is an interactive dashboard identity action, not an admin-token automation verb." } },
+  { method: "DELETE", path: "/api/remote-workspace/sessions/{id}", module: "server/management/remote-workspace-routes", mutates: true, mechanism: "regex", exempt: { reason: "session-only", why: "Stopping an interactive Remote Workspace model session belongs to the dashboard session that controls it." } },
   // server/management/system-routes
   { method: "GET", path: "/api/system/health", module: "server/management/system-routes", mutates: false },
   { method: "GET", path: "/api/system/memory", module: "server/management/system-routes", mutates: false },
diff --git a/src/server/ws-bridge.ts b/src/server/ws-bridge.ts
index 5777b45a10..3a8ee194b9 100644
--- a/src/server/ws-bridge.ts
+++ b/src/server/ws-bridge.ts
@@ -31,7 +31,10 @@ export interface WsData {
   /** Fixed-size logical session lane derived at the HTTP upgrade boundary. */
   sessionLaneId?: string;
   /** Discriminator: Responses reframing vs transparent live/realtime sideband relay. */
-  kind?: "responses" | "live-sideband";
+  kind?: "responses" | "live-sideband" | "remote-workspace-agent";
+  remoteWorkspaceConnection?: { receive(raw: string | Uint8Array): void };
+  remoteWorkspaceOpen?: (socket: ServerWebSocket<WsData>) => { receive(raw: string | Uint8Array): void };
+  remoteWorkspaceClose?: () => void;
   liveUpstream?: WebSocket;
   liveUpstreamUrl?: string;
   liveUpstreamHeaders?: Record<string, string>;
diff --git a/structure/INDEX.md b/structure/INDEX.md
index cb8b9250e5..a25322cc1e 100644
--- a/structure/INDEX.md
+++ b/structure/INDEX.md
@@ -42,7 +42,7 @@ The wire surfaces a client actually talks to.
 | [`data-planes/images.md`](data-planes/images.md) | Standalone image generation and edit relay. |
 | [`data-planes/search.md`](data-planes/search.md) | Hosted search relay and exact account selectors. |
 | [`data-planes/inbound-compat.md`](data-planes/inbound-compat.md) | Chat Completions inbound, Anthropic-shaped clients, and JSON-upstream streaming clients. |
-| [`remote-workspace.md`](remote-workspace.md) | Inactive workspace protocol, cryptographic identity primitives, and bounded framing. |
+| [`remote-workspace.md`](remote-workspace.md) | Opt-in workspace identity, executor grants, runtime adapters, management and dashboard integration. |
 
 ### Tier 4 — Providers and adapters
 
diff --git a/structure/adapters/registry.md b/structure/adapters/registry.md
index aa0bc914cb..5c9cdcbb1c 100644
--- a/structure/adapters/registry.md
+++ b/structure/adapters/registry.md
@@ -61,6 +61,8 @@ so the schema is not something a user can fix from configuration (issue #2673).
 
 > Decision record: [ADR-0093](../decisions/ADR-0093-moonshot-ref-with-siblings-normalization.md)
 
+Remote Workspace uses a separate, explicitly enabled server surface with structural WebSocket callbacks and awaited per-server cleanup; [its contract](../remote-workspace.md) owns that integration.
+
 ## Truncated tool finalization
 
 The bridge keeps an open function, custom, or tool-search call incomplete when an adapter ends with a recognized truncated stop reason. Streaming emits no argument/input completion frame for that open call, and buffered JSON applies the same status. A call already closed by its own tool-call end retains its completed state. The response remains incomplete, partial output is preserved, and truncated compaction never replaces history.
diff --git a/structure/catalog.md b/structure/catalog.md
index 49f0e353e1..d51950e18b 100644
--- a/structure/catalog.md
+++ b/structure/catalog.md
@@ -267,6 +267,8 @@ spelling; the V1 and compaction cap exemptions are preserved.
 Codex display-cache expiry, retained main-policy evidence, and reset history follow the
 [quota cache contract](providers/openai-tiers.md#quota-cache-and-short-window-history).
 
+Remote Workspace uses a separate, explicitly enabled server surface with structural WebSocket callbacks and awaited per-server cleanup; [its contract](remote-workspace.md) owns that integration.
+
 Chat helper admission in `src/server/responses/core.ts` follows the
 [deferred stored-main contract](providers/openai-tiers.md): only a needed Direct OpenAI helper
 claims stored main, after terminal vision, routed vision and search exclusions.
diff --git a/structure/clients/claude-desktop.md b/structure/clients/claude-desktop.md
index 294eba9695..21cec3b009 100644
--- a/structure/clients/claude-desktop.md
+++ b/structure/clients/claude-desktop.md
@@ -78,6 +78,8 @@ testable on any host: stubbing `process.platform` does not propagate to `os.plat
 
 The unregistered executor CLI module stores Remote Workspace state separately from client configuration; see [Remote Workspace](../remote-workspace.md).
 
+Remote Workspace uses a separate, explicitly enabled server surface with structural WebSocket callbacks and awaited per-server cleanup; [its contract](../remote-workspace.md) owns that integration.
+
 Chat helper admission in `src/server/responses/core.ts` follows the
 [deferred stored-main contract](../providers/openai-tiers.md): only a needed Direct OpenAI helper
 claims stored main, after terminal vision, routed vision and search exclusions.
diff --git a/structure/config.md b/structure/config.md
index 90b92d26ff..2c8be564f1 100644
--- a/structure/config.md
+++ b/structure/config.md
@@ -205,6 +205,8 @@ Codex display-cache expiry, retained main-policy evidence, and reset history fol
 
 The unregistered executor CLI module stores Remote Workspace state separately from client configuration; see [Remote Workspace](remote-workspace.md).
 
+Remote Workspace uses a separate, explicitly enabled server surface with structural WebSocket callbacks and awaited per-server cleanup; [its contract](remote-workspace.md) owns that integration.
+
 ## Paginated history writer boundary
 
 `src/codex/history-provider.ts` refuses external writes to paginated or migration-capable history. `src/codex/inject.ts` checks affected rows and manifest-owned restore targets before and after config/profile/journal changes, including successful journal and fallback restores, and compensates detected migration. Failed config restore stops later catalog/history work and rolls back a coordinated remove transition. See the [history writer contract](codex-home.md#paginated-history-writer-boundary) for guarantees and concurrent-writer limits.
diff --git a/structure/data-planes/images.md b/structure/data-planes/images.md
index d1d0193048..8aff4a9532 100644
--- a/structure/data-planes/images.md
+++ b/structure/data-planes/images.md
@@ -70,6 +70,8 @@ conflicts with `modelSupportsReasoningSummaries: false` for the same model.
 
 > Decision record: [ADR-0045](../decisions/ADR-0045-standalone-images.md)
 
+Remote Workspace uses a separate, explicitly enabled server surface with structural WebSocket callbacks and awaited per-server cleanup; [its contract](../remote-workspace.md) owns that integration.
+
 Chat helper admission in `src/server/responses/core.ts` follows the
 [deferred stored-main contract](../providers/openai-tiers.md): only a needed Direct OpenAI helper
 claims stored main, after terminal vision, routed vision and search exclusions.
diff --git a/structure/data-planes/inbound-compat.md b/structure/data-planes/inbound-compat.md
index 3e940b27a4..66788f7f48 100644
--- a/structure/data-planes/inbound-compat.md
+++ b/structure/data-planes/inbound-compat.md
@@ -111,6 +111,8 @@ reasoning ladder into `thinking.effortOptions`. Missing capabilities stay absent
 falling back to OpenCodex guesses, and the integration does not write the removed
 `thinking.effort` / `defaultEffort` fields because MCode owns the active effort per session.
 
+Remote Workspace uses a separate, explicitly enabled server surface with structural WebSocket callbacks and awaited per-server cleanup; [its contract](../remote-workspace.md) owns that integration.
+
 Chat helper admission in `src/server/responses/core.ts` follows the
 [deferred stored-main contract](../providers/openai-tiers.md): only a needed Direct OpenAI helper
 claims stored main, after terminal vision, routed vision and search exclusions.
diff --git a/structure/design-methodology.md b/structure/design-methodology.md
index 690b3b1287..14dd8c4aef 100644
--- a/structure/design-methodology.md
+++ b/structure/design-methodology.md
@@ -37,6 +37,8 @@ surfaces, run through all 3 stages in order.
 - 6 design dials: mood, lightness, density, shape, typography, motion
 - 7 axes total: design → domain → feature/data/security/ops/cost (derived)
 
+Remote Workspace uses a separate, explicitly enabled server surface with structural WebSocket callbacks and awaited per-server cleanup; [its contract](remote-workspace.md) owns that integration.
+
 The management quota DTO keeps Combo editing aligned with scoped inference evidence;
 see [Combo editor routing quota](gui-and-management-api.md#combo-editor-routing-quota).
 
diff --git a/structure/gui-and-management-api.md b/structure/gui-and-management-api.md
index 52453687dd..2904df6990 100644
--- a/structure/gui-and-management-api.md
+++ b/structure/gui-and-management-api.md
@@ -514,6 +514,8 @@ survives availability drift, while complete/native custom orders await explicit
 
 The shared atomic replacement publisher also identifies explicit Remote Workspace file writes as `remote-workspace`; its isolated owner and support limits are documented in [Remote Workspace](remote-workspace.md).
 
+Remote Workspace uses a separate, explicitly enabled server surface with structural WebSocket callbacks and awaited per-server cleanup; [its contract](remote-workspace.md) owns that integration.
+
 Chat helper admission in `src/server/responses/core.ts` follows the
 [deferred stored-main contract](providers/openai-tiers.md): only a needed Direct OpenAI helper
 claims stored main, after terminal vision, routed vision and search exclusions.
diff --git a/structure/manifest.json b/structure/manifest.json
index fd85177820..95c2063180 100644
--- a/structure/manifest.json
+++ b/structure/manifest.json
@@ -366,7 +366,7 @@
       "path": "remote-workspace.md",
       "tier": 3,
       "title": "Remote Workspace",
-      "scope": "Inactive workspace protocol, cryptographic identity primitives, and bounded framing.",
+      "scope": "Opt-in workspace identity, executor grants, runtime adapters, management and dashboard integration.",
       "documents": [
         "src/remote-control/"
       ]
diff --git a/structure/ops/docs-and-release.md b/structure/ops/docs-and-release.md
index b6c4077563..5fe735ed35 100644
--- a/structure/ops/docs-and-release.md
+++ b/structure/ops/docs-and-release.md
@@ -306,6 +306,8 @@ Codex display-cache expiry, retained main-policy evidence, and reset history fol
 
 The shared atomic replacement publisher also identifies explicit Remote Workspace file writes as `remote-workspace`; its isolated owner and support limits are documented in [Remote Workspace](../remote-workspace.md).
 
+Remote Workspace uses a separate, explicitly enabled server surface with structural WebSocket callbacks and awaited per-server cleanup; [its contract](../remote-workspace.md) owns that integration.
+
 The Combo guides describe the distinction between display quota and single-credential inference evidence used by routing. See [scoped provider quota](../runtime.md#scoped-provider-quota-for-combo-selection).
 
 The management quota DTO keeps Combo editing aligned with scoped inference evidence;
diff --git a/structure/ops/service-and-sidecars.md b/structure/ops/service-and-sidecars.md
index c8ef069110..7c6402c399 100644
--- a/structure/ops/service-and-sidecars.md
+++ b/structure/ops/service-and-sidecars.md
@@ -133,6 +133,8 @@ so the flag does not identify the peer responsible for corruption. Existing diag
 not rewritten. Audio devices, WebRTC media negotiation, captions and spoken handoff delivery remain
 client responsibilities.
 
+Remote Workspace uses a separate, explicitly enabled server surface with structural WebSocket callbacks and awaited per-server cleanup; [its contract](../remote-workspace.md) owns that integration.
+
 Chat helper admission in `src/server/responses/core.ts` follows the
 [deferred stored-main contract](../providers/openai-tiers.md): only a needed Direct OpenAI helper
 claims stored main, after terminal vision, routed vision and search exclusions.
diff --git a/structure/overview.md b/structure/overview.md
index 0c3e025727..6a8691b767 100644
--- a/structure/overview.md
+++ b/structure/overview.md
@@ -106,6 +106,8 @@ would pass while the rule was violated.
 
 The shared atomic replacement publisher also identifies explicit Remote Workspace file writes as `remote-workspace`; its isolated owner and support limits are documented in [Remote Workspace](remote-workspace.md).
 
+Remote Workspace uses a separate, explicitly enabled server surface with structural WebSocket callbacks and awaited per-server cleanup; [its contract](remote-workspace.md) owns that integration.
+
 The management quota DTO keeps Combo editing aligned with scoped inference evidence;
 see [Combo editor routing quota](gui-and-management-api.md#combo-editor-routing-quota).
 
diff --git a/structure/providers/xai-grok.md b/structure/providers/xai-grok.md
index fc6cf7c63f..876f7ac89f 100644
--- a/structure/providers/xai-grok.md
+++ b/structure/providers/xai-grok.md
@@ -54,6 +54,8 @@ malformed, gapped, oversized, contradictory, failed, or incomplete streams stay
 - **Safety & Idempotency:** Managed via `src/grok/reset-coupon-ledger.ts` using UUIDv4 operation tracking before upstream dispatch to prevent duplicate consumption during network flakes.
 - **Surfaces:** `ocx account grok-reset-coupons` in the terminal, and the dashboard at Providers > xAI Grok > Accounts, where each OAuth row carries a ticket badge with its remaining count and opens a redemption dialog (`gui/src/hooks/useGrokResetCoupons.ts`, `gui/src/components/provider-workspace/GrokResetCoupons.tsx`). The dashboard reads one `GET /api/grok/reset-coupons` per account with at most three in flight, always sends an explicit `tokenId` and a client-minted `operationId`, and treats redemption truth as the settled `code` rather than HTTP 200 — a replayed *failure* returns 200 with `replayed: true`. After a request times out it issues no further consume call, because a redemption whose ledger record is still `open` re-executes.
 
+Remote Workspace uses a separate, explicitly enabled server surface with structural WebSocket callbacks and awaited per-server cleanup; [its contract](../remote-workspace.md) owns that integration.
+
 Chat helper admission in `src/server/responses/core.ts` follows the
 [deferred stored-main contract](openai-tiers.md): only a needed Direct OpenAI helper
 claims stored main, after terminal vision, routed vision and search exclusions.
diff --git a/structure/remote-workspace.md b/structure/remote-workspace.md
index 787a0ca288..5f5d05a507 100644
--- a/structure/remote-workspace.md
+++ b/structure/remote-workspace.md
@@ -1,6 +1,6 @@
 # Remote Workspace
 
-`src/remote-control/` owns Remote Workspace contracts, explicit executor construction and Hub session adapters. No module is registered with server startup in this layer. Existing Remote Hub provider routing remains in `src/remote/` and is a separate capability.
+`src/remote-control/` owns Remote Workspace contracts, explicit executor construction and Hub session adapters. The server exposes this surface only with Hub role and OCX_REMOTE_WORKSPACE_ENABLED=1. The side-effect-free activation guard loads no services. Existing Remote Hub provider routing remains in `src/remote/` and is a separate capability.
 
 `src/remote-control/protocol.ts` owns frame and identity contracts. `src/remote-control/crypto.ts` implements signed handshakes and directional encryption. `src/remote-control/workspace-agent-protocol.ts` parses bounded control messages; `src/remote-control/workspace-rpc-framing.ts` bounds reassembly allocation, count and expiry. Importing these modules starts no process or timer; incomplete reassembly owns expiry timers after an explicit call.
 
@@ -10,10 +10,18 @@
 
 `src/remote-control/workspace-hub.ts`, `src/remote-control/workspace-device.ts` and `src/remote-control/workspace-sessions.ts` own separate persisted state. `src/remote-control/workspace-secret-store.ts` requires private permissions and rejects access failures rather than treating them as first-run absence. Publication reuses `src/config/atomic-write.ts`; workspace file publication uses the remote-workspace publisher in `src/lib/windows-atomic-replace.ts`.
 
-`src/remote-control/workspace-runtime.ts` is the lazy composition owner for Hub services. Codex, Claude and Pi adapters keep model processes on the Hub and expose selected remote tools. Their source configuration is not evidence of live CLI confinement. `src/cli/remote-workspace.ts` contains explicit executor pair/agent/status handling; it is not yet registered by this layer.
+`src/remote-control/workspace-runtime.ts` is the lazy composition owner for Hub services. Codex, Claude and Pi adapters keep model processes on the Hub and expose selected remote tools. Their source configuration is not evidence of live CLI confinement. `src/cli/remote-workspace.ts` contains registered executor pair/agent/status handling; the machine-readable entries live in `src/cli/capabilities.ts`.
 
 The optional terminal prototype in `src/remote-control/host.ts` invokes only a caller-supplied factory after authenticated traffic. `src/remote-control/relay.ts` routes opaque prototype envelopes after caller authorization. Neither is a production terminal service.
 
 Regression coverage lives in `tests/clients/remote-workspace-session-binding.test.ts`, `tests/clients/remote-workspace-secret-store.test.ts` and the adjacent protocol, agent-wire, device, hub, sessions and command-runner tests. Real CLI and native confinement tests require their explicit environments; generic suite success does not certify those paths. Windows command support remains unavailable pending a verified lifecycle owner.
 
+`src/server/index.ts` admits the opt-in pair exchange and bearer-authenticated agent upgrade after Origin and role checks. The unauthenticated loopback companion does not expose either endpoint. `src/server/management-api.ts` answers disabled workspace status before importing services; mutations require a dashboard session. `src/server/management/remote-workspace-routes.ts` reads bounded management JSON and uses the initialized Hub/session services.
+
+The listener retains an awaited shutdown callback only after optional activation. It refuses initialization once stop begins, starts listener admission closure and workspace cleanup concurrently, and awaits session shutdown before closing Hub connections in a finally path. Listener drain completes after these owned sockets close; cleanup failures still propagate. `src/server/ws-bridge.ts` carries structural receive/open/close callbacks without importing concrete workspace services.
+
+`gui/src/pages/RemoteWorkspace.tsx` defaults to read-only access, displays actual effective capabilities, and keeps Stop available while a prompt is pending. Error retries preserve draft text. The UI explains explicit Hub opt-in in each locale; no historical screenshot is evidence of the current surface.
+
 Hub runtime admission counts pending create/resume starts as well as live handles against global and per-device limits; every outcome releases its reservation. Stop and shutdown reclaim late resumed handles before clearing ownership. Coordinator result size limits normalize both response text and success, so bridge and MCP callers receive consistent errors.
+
+Prompt HTTP admission returns 202 with the existing session/event cursor; tracked operations publish terminal status for polling and attach a rejection observer immediately. Reconnect/resume cannot publish ready while a turn is active. The dashboard prefers newer local event cursors over stale polling, favors authoritative polling on ties, retains unconfirmed draft text with an uncertainty notice, and never retries prompt POSTs automatically.
diff --git a/structure/runtime.md b/structure/runtime.md
index 471fad541d..695201dd23 100644
--- a/structure/runtime.md
+++ b/structure/runtime.md
@@ -200,6 +200,8 @@ Codex display-cache expiry, retained main-policy evidence, and reset history fol
 
 The shared atomic replacement publisher also identifies explicit Remote Workspace file writes as `remote-workspace`; its isolated owner and support limits are documented in [Remote Workspace](remote-workspace.md).
 
+Remote Workspace uses a separate, explicitly enabled server surface with structural WebSocket callbacks and awaited per-server cleanup; [its contract](remote-workspace.md) owns that integration.
+
 Chat helper admission in `src/server/responses/core.ts` follows the
 [deferred stored-main contract](providers/openai-tiers.md): only a needed Direct OpenAI helper
 claims stored main, after terminal vision, routed vision and search exclusions.
diff --git a/structure/subagents.md b/structure/subagents.md
index 24d37af883..ccda79440d 100644
--- a/structure/subagents.md
+++ b/structure/subagents.md
@@ -199,6 +199,8 @@ Native Codex advertisements still follow display priority; private guidance rank
 Codex display-cache expiry, retained main-policy evidence, and reset history follow the
 [quota cache contract](providers/openai-tiers.md#quota-cache-and-short-window-history).
 
+Remote Workspace uses a separate, explicitly enabled server surface with structural WebSocket callbacks and awaited per-server cleanup; [its contract](remote-workspace.md) owns that integration.
+
 Chat helper admission in `src/server/responses/core.ts` follows the
 [deferred stored-main contract](providers/openai-tiers.md): only a needed Direct OpenAI helper
 claims stored main, after terminal vision, routed vision and search exclusions.
diff --git a/structure/transports/inventory.md b/structure/transports/inventory.md
index 937bd6fde3..7ce087bcab 100644
--- a/structure/transports/inventory.md
+++ b/structure/transports/inventory.md
@@ -62,6 +62,8 @@ executor contract. Main-request migration must not treat that branch as fixed-tr
 
 The shared atomic replacement publisher also identifies explicit Remote Workspace file writes as `remote-workspace`; its isolated owner and support limits are documented in [Remote Workspace](../remote-workspace.md).
 
+Remote Workspace uses a separate, explicitly enabled server surface with structural WebSocket callbacks and awaited per-server cleanup; [its contract](../remote-workspace.md) owns that integration.
+
 Chat helper admission in `src/server/responses/core.ts` follows the
 [deferred stored-main contract](../providers/openai-tiers.md): only a needed Direct OpenAI helper
 claims stored main, after terminal vision, routed vision and search exclusions.
diff --git a/structure/transports/responses.md b/structure/transports/responses.md
index 0289bdce99..ecca073095 100644
--- a/structure/transports/responses.md
+++ b/structure/transports/responses.md
@@ -552,6 +552,8 @@ not retried.
 
 The shared atomic replacement publisher also identifies explicit Remote Workspace file writes as `remote-workspace`; its isolated owner and support limits are documented in [Remote Workspace](../remote-workspace.md).
 
+Remote Workspace uses a separate, explicitly enabled server surface with structural WebSocket callbacks and awaited per-server cleanup; [its contract](../remote-workspace.md) owns that integration.
+
 Chat helper admission in `src/server/responses/core.ts` follows the
 [deferred stored-main contract](../providers/openai-tiers.md): only a needed Direct OpenAI helper
 claims stored main, after terminal vision, routed vision and search exclusions.
diff --git a/structure/transports/streaming-health.md b/structure/transports/streaming-health.md
index 6a5574c6d2..1c050e5497 100644
--- a/structure/transports/streaming-health.md
+++ b/structure/transports/streaming-health.md
@@ -190,6 +190,8 @@ WebSocket clients observe the same canonical lifecycle.
 frame rather than always emitting `response.completed`. If the response status is `failed`, a
 `response.failed` frame is sent; otherwise `response.completed` carries through the original status.
 
+Remote Workspace uses a separate, explicitly enabled server surface with structural WebSocket callbacks and awaited per-server cleanup; [its contract](../remote-workspace.md) owns that integration.
+
 Chat helper admission in `src/server/responses/core.ts` follows the
 [deferred stored-main contract](../providers/openai-tiers.md): only a needed Direct OpenAI helper
 claims stored main, after terminal vision, routed vision and search exclusions.
diff --git a/tests/cli/cli-headless-parity.test.ts b/tests/cli/cli-headless-parity.test.ts
index 0206c8e54a..63a6d7d08e 100644
--- a/tests/cli/cli-headless-parity.test.ts
+++ b/tests/cli/cli-headless-parity.test.ts
@@ -307,6 +307,12 @@ describe("headless GUI parity CLI", () => {
       // history remains available through observe/index tooling.
       ["/api/routing-profiles", "ocx route policy"],
       ["/api/routing-analytics", "(none — GUI analytics surface; history via ocx observe/logs)"],
+      // Remote Workspace is one product family in both surfaces. The current CLI owns
+      // executor pairing, presence, and local status; Hub/device/session inspection is
+      // intentionally dashboard-only until the deferred Hub-status verbs documented in
+      // the management route registry land. Naming the family here does not claim those
+      // local and Hub status payloads are equivalent.
+      ["/api/remote-workspace", "ocx remote-workspace"],
       ["/api/shadow", "ocx models"],
       ["/api/sidecar", "ocx agent"],
       ["/api/startup", "ocx system"],
diff --git a/tests/clients/client-machine-listener.test.ts b/tests/clients/client-machine-listener.test.ts
index 1f2777ac6b..6e4422a06a 100644
--- a/tests/clients/client-machine-listener.test.ts
+++ b/tests/clients/client-machine-listener.test.ts
@@ -5,7 +5,10 @@ import { join } from "node:path";
 import type { Server } from "bun";
 import { startMachineListener } from "../../src/client/machine-listener";
 import { serveGuiFile } from "../../src/server/gui-static";
-import type { OcxClientConnectionConfig } from "../../src/types";
+import type { OcxClientConnectionConfig, OcxConfig } from "../../src/types";
+import { RemoteWorkspaceSessionService } from "../../src/remote-control/workspace-sessions";
+import type { RemoteWorkspaceHub } from "../../src/remote-control/workspace-hub";
+import { handleManagementAPI } from "../../src/server/management-api";
 import type { ManagementAuthState } from "../../src/server/management-auth";
 import { removeTreeWithRetry } from "../helpers/remove-tree";
 import { repoPath } from "../helpers/repo-root";
@@ -79,6 +82,85 @@ async function guiHeaders(server: Server<unknown>, mutation = false): Promise<He
 }
 
 describe("client machine listener", () => {
+  test("relayed workspace prompt acknowledges acceptance before the model turn completes", async () => {
+    const oldEnabled = process.env.OCX_REMOTE_WORKSPACE_ENABLED;
+    process.env.OCX_REMOTE_WORKSPACE_ENABLED = "1";
+    const deviceId = "11111111-1111-4111-8111-111111111111";
+    const rootId = "22222222-2222-4222-8222-222222222222";
+    let finish!: () => void;
+    const held = new Promise<void>(resolve => { finish = resolve; });
+    let completed = false;
+    let observeCompletion = false;
+    let terminal!: () => void;
+    const settled = new Promise<void>(resolve => { terminal = resolve; });
+    const hub = {
+      listDevices: () => [{ id: deviceId, name: "Executor", roots: [{ id: rootId, label: "Project" }], capabilities: ["workspace.read"], online: true }],
+      connection: () => ({
+        capabilities: () => ["workspace.read"],
+        openSession: async () => ({ isOnline: () => true, invoke: async () => ({ ok: true, value: null }) }),
+        closeSession: async () => {},
+      }),
+    } as unknown as RemoteWorkspaceHub;
+    const sessions = new RemoteWorkspaceSessionService(hub, [{
+      profile: "codex", available: async () => ({ available: true }),
+      start: async () => ({ threadId: "relay-thread", prompt: async () => { await held; completed = true; }, stop: async () => { finish(); } }),
+    }], Date.now, {
+      load: () => null,
+      save: state => { if (observeCompletion && state.sessions.some(session => session.status === "ready")) terminal(); },
+    });
+    const hubConfig = { port: 0, hostname: "0.0.0.0", runtimeRole: "hub", hub: { managementPublicOrigin: "https://hub.example.test" }, defaultProvider: "none", providers: {} } as OcxConfig;
+    let deadline: ReturnType<typeof setTimeout> | undefined;
+    try {
+      const created = await sessions.create({ profile: "codex", deviceId, rootId });
+      observeCompletion = true;
+      const server = startMachineListener(0, {
+        state: connection("relay"), managementAuthState: authState(),
+        fetchImpl: (async (input, init) => {
+          const request = new Request(String(input), init);
+          request.headers.set("Host", new URL(request.url).host);
+          return await handleManagementAPI(request, new URL(request.url), hubConfig, {
+            remoteWorkspaceHub: hub, remoteWorkspaceSessions: sessions,
+          }, "gui-session") ?? new Response(null, { status: 404 });
+        }) as typeof fetch,
+      });
+      servers.push(server);
+      const local = await guiHeaders(server, true);
+      hubConfig.corsAllowOrigins = [local.get("Origin")!];
+      const headers = new Headers({
+        Origin: local.get("Origin")!, "Content-Type": "application/json",
+        "X-OpenCodex-Machine-Session": local.get("X-OpenCodex-API-Key")!,
+        "X-OpenCodex-Machine-GUI-Origin": local.get("X-OpenCodex-GUI-Origin")!,
+        "X-OpenCodex-Machine-CSRF-Token": local.get("X-OpenCodex-CSRF-Token")!,
+        "X-OpenCodex-API-Key": "ocx_session_hub",
+        "X-OpenCodex-GUI-Origin": local.get("X-OpenCodex-GUI-Origin")!,
+        "X-OpenCodex-CSRF-Token": "fixture-hub-csrf",
+      });
+      const prefix = "/api/machine/hub-relay/api/remote-workspace/sessions";
+      const acknowledged = await Promise.race([
+        fetch(new URL(`${prefix}/${created.id}/prompt`, server.url), { method: "POST", headers, body: JSON.stringify({ prompt: "Held turn" }) }),
+        new Promise<never>((_resolve, reject) => { deadline = setTimeout(() => reject(new Error("relay waited for model completion")), 5_000); }),
+      ]);
+      expect(acknowledged.status).toBe(202);
+      const accepted = await acknowledged.json() as { id: string; status: string; events: Array<{ sequence: number }> };
+      expect(accepted.id).toBe(created.id);
+      expect(accepted.status).toBe("running");
+      expect(completed).toBe(false);
+      const cursor = accepted.events.at(-1)!.sequence;
+      finish();
+      await settled;
+      const poll = await fetch(new URL(prefix, server.url), { headers });
+      const state = await poll.json() as { sessions: Array<{ status: string; events: Array<{ sequence: number }> }> };
+      expect(state.sessions[0]!.status).toBe("ready");
+      expect(state.sessions[0]!.events.at(-1)!.sequence).toBeGreaterThan(cursor);
+    } finally {
+      clearTimeout(deadline);
+      finish();
+      await sessions.stopAll();
+      if (oldEnabled === undefined) delete process.env.OCX_REMOTE_WORKSPACE_ENABLED;
+      else process.env.OCX_REMOTE_WORKSPACE_ENABLED = oldEnabled;
+    }
+  }, 15_000);
+
   test("binds IPv4 loopback and default-denies shared/data-plane routes", async () => {
     const server = startMachineListener(0, { state: connection(), managementAuthState: authState() });
     servers.push(server);
diff --git a/tests/clients/remote-workspace-activation.test.ts b/tests/clients/remote-workspace-activation.test.ts
new file mode 100644
index 0000000000..d05885bc37
--- /dev/null
+++ b/tests/clients/remote-workspace-activation.test.ts
@@ -0,0 +1,45 @@
+import { afterEach, expect, test } from "bun:test";
+import { remoteWorkspaceEnabled } from "../../src/remote-control/workspace-activation";
+import { handleManagementAPI } from "../../src/server/management-api";
+import type { ManagementApiDeps } from "../../src/server/management/context";
+import type { OcxConfig } from "../../src/types";
+
+const prior = process.env.OCX_REMOTE_WORKSPACE_ENABLED;
+afterEach(() => {
+  if (prior === undefined) delete process.env.OCX_REMOTE_WORKSPACE_ENABLED;
+  else process.env.OCX_REMOTE_WORKSPACE_ENABLED = prior;
+});
+const config = { port: 10100, runtimeRole: "hub", defaultProvider: "none", providers: {} } as OcxConfig;
+
+test("workspace activation requires both Hub role and exact explicit opt-in", () => {
+  expect(remoteWorkspaceEnabled(config, "1")).toBe(true);
+  for (const value of ["", "0", "true", "yes"]) expect(remoteWorkspaceEnabled(config, value)).toBe(false);
+  expect(remoteWorkspaceEnabled({ runtimeRole: "standalone" }, "1")).toBe(false);
+});
+
+test("disabled management status and mutations never resolve optional services", async () => {
+  delete process.env.OCX_REMOTE_WORKSPACE_ENABLED;
+  const deps: ManagementApiDeps = {
+    get remoteWorkspaceHub() { throw new Error("must not resolve hub"); },
+    get remoteWorkspaceSessions() { throw new Error("must not resolve sessions"); },
+  };
+  const url = new URL("http://127.0.0.1:10100/api/remote-workspace");
+  const status = await handleManagementAPI(new Request(url, { headers: { host: url.host } }), url, config, deps, "gui-session");
+  expect(status?.status).toBe(200);
+  expect(await status?.json()).toMatchObject({ available: false, devices: [], sessions: [] });
+  const mutationUrl = new URL(`${url}/pairing`);
+  const mutation = await handleManagementAPI(new Request(mutationUrl, { method: "POST", headers: { host: mutationUrl.host } }), mutationUrl, config, deps, "gui-session");
+  expect(mutation?.status).toBe(404);
+});
+
+test("an admin token cannot initialize a consent-bearing workspace mutation", async () => {
+  process.env.OCX_REMOTE_WORKSPACE_ENABLED = "1";
+  const deps: ManagementApiDeps = {
+    get remoteWorkspaceHub() { throw new Error("must not resolve hub"); },
+    get remoteWorkspaceSessions() { throw new Error("must not resolve sessions"); },
+  };
+  const url = new URL("http://127.0.0.1:10100/api/remote-workspace/pairing");
+  const result = await handleManagementAPI(new Request(url, { method: "POST", headers: { host: url.host } }), url, config, deps, "admin-token");
+  expect(result?.status).toBe(403);
+  expect(await result?.json()).toEqual({ error: "A dashboard session is required for Remote Workspace changes." });
+});
diff --git a/tests/clients/remote-workspace-command-runner.test.ts b/tests/clients/remote-workspace-command-runner.test.ts
index 9595b2b4f3..376ed9e0c3 100644
--- a/tests/clients/remote-workspace-command-runner.test.ts
+++ b/tests/clients/remote-workspace-command-runner.test.ts
@@ -32,14 +32,25 @@ function fixture() {
 }
 
 function fakeNativeHelper(root: string, response: Record<string, unknown>, requestPath?: string) {
-  const path = join(root, "ocx-remote-helper-test");
-  const encodedResponse = JSON.stringify(response).replaceAll("'", "'\\''");
-  const requestCapture = requestPath
-    ? `input=$(cat); printf '%s' "$input" > '${requestPath.replaceAll("'", "'\\''")}'`
-    : "cat >/dev/null";
-  writeFileSync(path, `#!/bin/sh\nset -eu\n${requestCapture}\nprintf '%s\\n' '${encodedResponse}'\n`, { mode: 0o700 });
+  const path = join(root, "ocx-remote-helper-test.mjs");
+  const source = [
+    'const input = await new Response(Bun.stdin.stream()).text();',
+    requestPath ? `await Bun.write(${JSON.stringify(requestPath)}, input);` : '',
+    `process.stdout.write(${JSON.stringify(JSON.stringify(response) + "\n")});`,
+  ].join("\n");
+  writeFileSync(path, source, { mode: 0o700 });
   chmodSync(path, 0o700);
-  return pinRemoteWorkspaceNativeHelper(path);
+  const helper = pinRemoteWorkspaceNativeHelper(path);
+  // Exercise real pipes on every host while keeping the native launch boundary observable.
+  // Production still launches only its pinned native helper, never this fixture interpreter.
+  const spawn = ((argv: string[], options: { stdin: "pipe"; stdout: "pipe"; stderr: "pipe"; cwd: string; env: Record<string, string> }) => {
+    expect(argv).toEqual([helper.path]);
+    expect(options.stdin).toBe("pipe");
+    expect(options.stdout).toBe("pipe");
+    expect(options.stderr).toBe("pipe");
+    return Bun.spawn([process.execPath, helper.path], options);
+  }) as typeof Bun.spawn;
+  return { helper, spawn };
 }
 
 describe("remote workspace Linux command sandbox", () => {
@@ -61,7 +72,7 @@ describe("remote workspace Linux command sandbox", () => {
 
   test("Windows command capability stays unavailable even with a positive probe seam", () => {
     const state = fixture();
-    const helper = fakeNativeHelper(state.root, { version: 1, ok: true, probe: true });
+    const { helper } = fakeNativeHelper(state.root, { version: 1, ok: true, probe: true });
     let probes = 0;
     expect(nativeRemoteWorkspaceCommandRunnerAvailable({
       platform: "win32", helper,
@@ -126,7 +137,7 @@ describe("remote workspace Linux command sandbox", () => {
 
   test("advertises native exec only after a digest-pinned confinement probe", () => {
     const state = fixture();
-    const helper = fakeNativeHelper(state.root, { version: 1, ok: true, probe: true });
+    const { helper } = fakeNativeHelper(state.root, { version: 1, ok: true, probe: true });
     let probeRequest: unknown;
     expect(nativeRemoteWorkspaceCommandRunnerAvailable({
       helper,
@@ -158,7 +169,7 @@ describe("remote workspace Linux command sandbox", () => {
   test("sends native command authority over bounded stdin and decodes one strict result", async () => {
     const state = fixture();
     const requestPath = join(state.root, "request.json");
-    const helper = fakeNativeHelper(state.root, {
+    const { helper, spawn } = fakeNativeHelper(state.root, {
       version: 1,
       ok: true,
       exitCode: 7,
@@ -167,6 +178,7 @@ describe("remote workspace Linux command sandbox", () => {
     }, requestPath);
     const runner = createNativeRemoteWorkspaceCommandRunner({
       helper,
+      spawn,
       platform: "darwin",
       writableRoots: [state.workspace],
       probe: () => ({ version: 1, ok: true, probe: true }),
@@ -196,7 +208,7 @@ describe("remote workspace Linux command sandbox", () => {
 
   test("rejects widened or malformed native helper responses", async () => {
     const state = fixture();
-    const helper = fakeNativeHelper(state.root, {
+    const { helper, spawn } = fakeNativeHelper(state.root, {
       version: 1,
       ok: true,
       exitCode: 0,
@@ -205,6 +217,7 @@ describe("remote workspace Linux command sandbox", () => {
     });
     const runner = createNativeRemoteWorkspaceCommandRunner({
       helper,
+      spawn,
       platform: "darwin",
       writableRoots: [state.workspace],
       probe: () => ({ version: 1, ok: true, probe: true }),
@@ -220,7 +233,7 @@ describe("remote workspace Linux command sandbox", () => {
 
   test("never advertises or invokes a native helper from inside a writable workspace", async () => {
     const state = fixture();
-    const helper = fakeNativeHelper(state.workspace, {
+    const { helper } = fakeNativeHelper(state.workspace, {
       version: 1,
       ok: true,
       exitCode: 0,
@@ -242,7 +255,7 @@ describe("remote workspace Linux command sandbox", () => {
     const state = fixture();
     const other = join(state.root, "other-workspace");
     mkdirSync(other);
-    const helper = fakeNativeHelper(state.root, {
+    const { helper, spawn } = fakeNativeHelper(state.root, {
       version: 1,
       ok: true,
       exitCode: 0,
@@ -251,6 +264,7 @@ describe("remote workspace Linux command sandbox", () => {
     });
     const runner = createNativeRemoteWorkspaceCommandRunner({
       helper,
+      spawn,
       platform: "darwin",
       writableRoots: [state.workspace],
       probe: () => ({ version: 1, ok: true, probe: true }),
diff --git a/tests/clients/remote-workspace-management.test.ts b/tests/clients/remote-workspace-management.test.ts
new file mode 100644
index 0000000000..5b911551ac
--- /dev/null
+++ b/tests/clients/remote-workspace-management.test.ts
@@ -0,0 +1,195 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { randomUUID } from "node:crypto";
+import { handleManagementAPI } from "../../src/server/management-api";
+import {
+  RemoteWorkspaceHub,
+  generateRemoteControlIdentityKeyPair,
+  type RemoteWorkspaceHubState,
+  type RemoteWorkspaceHubStateStore,
+  type RemoteWorkspaceSessionService,
+} from "../../src/remote-control";
+import type { OcxConfig } from "../../src/types";
+
+const previousEnabled = process.env.OCX_REMOTE_WORKSPACE_ENABLED;
+beforeEach(() => { process.env.OCX_REMOTE_WORKSPACE_ENABLED = "1"; });
+afterEach(() => { if (previousEnabled === undefined) delete process.env.OCX_REMOTE_WORKSPACE_ENABLED; else process.env.OCX_REMOTE_WORKSPACE_ENABLED = previousEnabled; });
+
+class MemoryStore implements RemoteWorkspaceHubStateStore {
+  state: RemoteWorkspaceHubState | null = null;
+  load() { return this.state ? structuredClone(this.state) : null; }
+  save(state: RemoteWorkspaceHubState) { this.state = structuredClone(state); }
+}
+
+const hubConfig = {
+  port: 10100,
+  runtimeRole: "hub",
+  defaultProvider: "none",
+  providers: {},
+} as OcxConfig;
+
+async function call(
+  config: OcxConfig,
+  hub: RemoteWorkspaceHub,
+  method: string,
+  path: string,
+  principal: "admin-token" | "gui-session" = "gui-session",
+  body?: unknown,
+  sessions: RemoteWorkspaceSessionService = emptySessions,
+): Promise<{ status: number; body: Record<string, unknown> }> {
+  const url = new URL(`http://127.0.0.1:10100${path}`);
+  const req = new Request(url, {
+    method,
+    headers: { host: "127.0.0.1:10100", ...(body === undefined ? {} : { "content-type": "application/json" }) },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+  const response = await handleManagementAPI(req, url, config, {
+    remoteWorkspaceHub: hub,
+    remoteWorkspaceSessions: sessions,
+  }, principal);
+  if (!response) throw new Error("Remote Workspace management route was not mounted");
+  return { status: response.status, body: await response.json() as Record<string, unknown> };
+}
+
+const emptySessions = {
+  async availability() {
+    return {
+      codex: { available: true, version: "test" },
+      claude: { available: false, reason: "not installed" },
+      pi: { available: false, reason: "not installed" },
+    };
+  },
+  list: () => [],
+} as unknown as RemoteWorkspaceSessionService;
+
+describe("Remote Workspace management routes", () => {
+  test("lists devices and requires a GUI consent session to create enrollment grants", async () => {
+    const hub = new RemoteWorkspaceHub(new MemoryStore());
+    const initial = await call(hubConfig, hub, "GET", "/api/remote-workspace", "admin-token");
+    expect(initial).toEqual({
+      status: 200,
+      body: {
+        available: true,
+        devices: [],
+        runtimes: {
+          codex: { available: true, version: "test" },
+          claude: { available: false, reason: "not installed" },
+          pi: { available: false, reason: "not installed" },
+        },
+        sessions: [],
+      },
+    });
+    const denied = await call(hubConfig, hub, "POST", "/api/remote-workspace/pairing", "admin-token");
+    expect(denied.status).toBe(403);
+    const created = await call(hubConfig, hub, "POST", "/api/remote-workspace/pairing");
+    expect(created.status).toBe(201);
+    expect(created.body.code).toMatch(/^[A-Z2-9]{4}-[A-Z2-9]{4}-[A-Z2-9]{4}$/);
+    expect(Date.parse(String(created.body.expiresAt))).toBeGreaterThan(Date.now());
+  });
+
+  test("revokes only the selected paired computer", async () => {
+    const hub = new RemoteWorkspaceHub(new MemoryStore());
+    const grant = hub.createPairingGrant();
+    const paired = hub.pairDevice({
+      code: grant.code,
+      name: "Computer 2",
+      platform: "linux-x64",
+      publicKey: generateRemoteControlIdentityKeyPair().publicKey,
+      roots: [{ id: randomUUID(), label: "Project" }],
+    });
+    const denied = await call(
+      hubConfig,
+      hub,
+      "DELETE",
+      `/api/remote-workspace/devices/${paired.device.id}`,
+      "admin-token",
+    );
+    expect(denied.status).toBe(403);
+    const revoked = await call(hubConfig, hub, "DELETE", `/api/remote-workspace/devices/${paired.device.id}`);
+    expect(revoked).toEqual({ status: 200, body: { ok: true } });
+    expect(hub.listDevices()).toEqual([]);
+  });
+
+  test("reports that a standalone proxy is not a Remote Workspace hub", async () => {
+    const hub = new RemoteWorkspaceHub(new MemoryStore());
+    const config = { ...hubConfig, runtimeRole: "standalone" as const };
+    const result = await call(config, hub, "GET", "/api/remote-workspace");
+    expect(result.status).toBe(200);
+    expect(result.body.available).toBe(false);
+  });
+
+  test("requires a GUI session for session mutations and routes the selected target", async () => {
+    const hub = new RemoteWorkspaceHub(new MemoryStore());
+    const sessionId = randomUUID();
+    const calls: unknown[] = [];
+    const summary = {
+      id: sessionId,
+      profile: "codex" as const,
+      accessMode: "read-only" as const,
+      deviceId: randomUUID(),
+      deviceName: "Computer 2",
+      rootId: randomUUID(),
+      rootLabel: "Project",
+      capabilities: ["workspace.read", "workspace.write", "workspace.exec"] as const,
+      tools: ["list_directory", "read_file", "write_file", "exec"] as const,
+      threadId: "thread-1",
+      resumable: true,
+      status: "ready" as const,
+      createdAt: "2026-01-01T00:00:00.000Z",
+      updatedAt: "2026-01-01T00:00:00.000Z",
+      events: [],
+    };
+    const sessions = {
+      availability: emptySessions.availability.bind(emptySessions),
+      list: () => [summary],
+      async create(input: unknown) { calls.push(["create", input]); return summary; },
+      submitPrompt(id: string, prompt: unknown) { calls.push(["prompt", id, prompt]); return summary; },
+      async stop(id: string) { calls.push(["stop", id]); return true; },
+    } as unknown as RemoteWorkspaceSessionService;
+
+    const denied = await call(
+      hubConfig,
+      hub,
+      "POST",
+      "/api/remote-workspace/sessions",
+      "admin-token",
+      { profile: "codex", deviceId: summary.deviceId, rootId: summary.rootId },
+      sessions,
+    );
+    expect(denied.status).toBe(403);
+    const created = await call(
+      hubConfig,
+      hub,
+      "POST",
+      "/api/remote-workspace/sessions",
+      "gui-session",
+      { profile: "codex", deviceId: summary.deviceId, rootId: summary.rootId },
+      sessions,
+    );
+    expect(created.status).toBe(201);
+    const prompted = await call(
+      hubConfig,
+      hub,
+      "POST",
+      `/api/remote-workspace/sessions/${sessionId}/prompt`,
+      "gui-session",
+      { prompt: "Run on Computer 2" },
+      sessions,
+    );
+    expect(prompted.status).toBe(202);
+    const stopped = await call(
+      hubConfig,
+      hub,
+      "DELETE",
+      `/api/remote-workspace/sessions/${sessionId}`,
+      "gui-session",
+      undefined,
+      sessions,
+    );
+    expect(stopped.status).toBe(200);
+    expect(calls).toEqual([
+      ["create", { profile: "codex", deviceId: summary.deviceId, rootId: summary.rootId, accessMode: "read-only" }],
+      ["prompt", sessionId, "Run on Computer 2"],
+      ["stop", sessionId],
+    ]);
+  });
+});
diff --git a/tests/clients/remote-workspace-server.test.ts b/tests/clients/remote-workspace-server.test.ts
new file mode 100644
index 0000000000..e8b1b65a54
--- /dev/null
+++ b/tests/clients/remote-workspace-server.test.ts
@@ -0,0 +1,427 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  RemoteWorkspaceHub,
+  connectRemoteWorkspaceAgent,
+  generateRemoteControlIdentityKeyPair,
+  pairRemoteWorkspaceDevice,
+  type RemoteWorkspaceDeviceState,
+  type RemoteWorkspaceDeviceStateStore,
+  type RemoteWorkspaceHubState,
+  type RemoteWorkspaceHubStateStore,
+  type RemoteWorkspaceSessionService,
+} from "../../src/remote-control";
+import { startServer } from "../../src/server";
+import { findAvailablePort } from "../../src/server/ports";
+import type { ManagementAuthState } from "../../src/server/management-auth";
+import type { OcxConfig } from "../../src/types";
+import { removeTreeWithRetry } from "../helpers/remove-tree";
+
+class HubStore implements RemoteWorkspaceHubStateStore {
+  state: RemoteWorkspaceHubState | null = null;
+  load() { return this.state ? structuredClone(this.state) : null; }
+  save(state: RemoteWorkspaceHubState) { this.state = structuredClone(state); }
+}
+
+class DeviceStore implements RemoteWorkspaceDeviceStateStore {
+  state: RemoteWorkspaceDeviceState | null = null;
+  load() { return this.state ? structuredClone(this.state) : null; }
+  save(state: RemoteWorkspaceDeviceState) { this.state = structuredClone(state); }
+}
+
+const previous = {
+  enabled: process.env.OCX_REMOTE_WORKSPACE_ENABLED,
+  home: process.env.HOME,
+  ocx: process.env.OPENCODEX_HOME,
+  codex: process.env.CODEX_HOME,
+};
+let root = "";
+let ocxHome = "";
+
+beforeEach(() => {
+  process.env.OCX_REMOTE_WORKSPACE_ENABLED = "1";
+  root = mkdtempSync(join(tmpdir(), "ocx-remote-server-"));
+  const home = join(root, "home");
+  const ocx = join(root, "ocx");
+  const codex = join(root, "codex");
+  mkdirSync(home);
+  mkdirSync(ocx);
+  mkdirSync(codex);
+  process.env.HOME = home;
+  process.env.OPENCODEX_HOME = ocx;
+  process.env.CODEX_HOME = codex;
+  ocxHome = ocx;
+});
+
+afterEach(() => {
+  for (const [key, value] of [
+    ["OCX_REMOTE_WORKSPACE_ENABLED", previous.enabled],
+    ["HOME", previous.home],
+    ["OPENCODEX_HOME", previous.ocx],
+    ["CODEX_HOME", previous.codex],
+  ] as const) {
+    if (value === undefined) delete process.env[key];
+    else process.env[key] = value;
+  }
+  if (root) removeTreeWithRetry(root);
+  root = "";
+  ocxHome = "";
+});
+
+function writeTestConfig(value: OcxConfig): void {
+  // This integration needs startServer's real load path, but must never call the production
+  // persistence helper. The repository test wrapper places this direct fixture write under an
+  // isolated OPENCODEX_HOME, and the protected real home remains outside the process namespace.
+  writeFileSync(join(ocxHome, "config.json"), `${JSON.stringify(value)}\n`, { mode: 0o600 });
+}
+
+function config(): OcxConfig {
+  return {
+    port: 0,
+    hostname: "127.0.0.1",
+    runtimeRole: "hub",
+    defaultProvider: "test",
+    providers: {
+      test: {
+        adapter: "openai-chat",
+        baseUrl: "https://example.test/v1",
+        disabled: true,
+        models: ["test-model"],
+      },
+    },
+    subagentModels: [],
+    claudeCode: { enabled: false },
+    codexAutoStart: false,
+  };
+}
+
+function managementAuth(): ManagementAuthState {
+  return {
+    available: true,
+    token: "ocx_admin_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmno",
+    source: "environment",
+    sessions: new Map(),
+    pairingGrants: new Map(),
+  };
+}
+
+describe("Remote Workspace hub HTTP and WebSocket integration", () => {
+  test("graceful server stop closes a still-connected executor socket", async () => {
+    const workspace = join(root, "graceful-executor");
+    mkdirSync(workspace);
+    writeTestConfig(config());
+    const hub = new RemoteWorkspaceHub(new HubStore());
+    const server = startServer(0, { managementAuthState: managementAuth(), managementApi: { remoteWorkspaceHub: hub } });
+    let handle: ReturnType<typeof connectRemoteWorkspaceAgent> | null = null;
+    let deadline: ReturnType<typeof setTimeout> | undefined;
+    try {
+      const grant = hub.createPairingGrant();
+      const state = await pairRemoteWorkspaceDevice({
+        hubUrl: server.url.toString(), pairingCode: grant.code, name: "Executor", devicePlatform: "test",
+        roots: [{ path: workspace, label: "Project" }], store: new DeviceStore(),
+      });
+      handle = connectRemoteWorkspaceAgent({ state, commandRunner: null });
+      await handle.connected;
+      expect(hub.connection(state.deviceId)).not.toBeNull();
+      await Promise.race([
+        server.stop(false),
+        new Promise<never>((_resolve, reject) => {
+          deadline = setTimeout(() => reject(new Error("graceful stop did not close the executor")), 5_000);
+        }),
+      ]);
+      expect(hub.connection(state.deviceId)).toBeNull();
+    } finally {
+      clearTimeout(deadline);
+      handle?.stop();
+      if (handle) await handle.closed;
+      await server.stop(true);
+    }
+  }, 15_000);
+
+  test("pairs an OCX-only executor and carries encrypted file work over its outbound socket", async () => {
+    const workspace = join(root, "computer-2-project");
+    mkdirSync(workspace);
+    writeFileSync(join(workspace, "marker.txt"), "from-computer-2");
+    writeTestConfig(config());
+    const hub = new RemoteWorkspaceHub(new HubStore());
+    const server = startServer(0, {
+      managementAuthState: managementAuth(),
+      managementApi: { remoteWorkspaceHub: hub },
+    });
+    const deviceStore = new DeviceStore();
+    let handle: ReturnType<typeof connectRemoteWorkspaceAgent> | null = null;
+    try {
+      const grant = hub.createPairingGrant();
+      const state = await pairRemoteWorkspaceDevice({
+        hubUrl: server.url.toString(),
+        pairingCode: grant.code,
+        name: "Computer 2",
+        devicePlatform: "linux-x64",
+        roots: [{ path: workspace, label: "Project" }],
+        store: deviceStore,
+      });
+      handle = connectRemoteWorkspaceAgent({ state, commandRunner: null });
+      await handle.connected;
+      expect(hub.listDevices()[0]).toMatchObject({
+        id: state.deviceId,
+        online: true,
+        name: "Computer 2",
+        capabilities: ["workspace.read", "workspace.write"],
+      });
+
+      const connection = hub.connection(state.deviceId);
+      if (!connection) throw new Error("paired executor did not attach to the hub");
+      const sessionId = crypto.randomUUID();
+      const transport = await connection.openSession({
+        sessionId,
+        rootId: state.roots[0]!.id,
+        profile: "claude",
+        capabilities: ["workspace.read"],
+      });
+      const result = await transport.invoke({
+        requestId: crypto.randomUUID(),
+        sessionId,
+        executorDeviceId: state.deviceId,
+        rootId: state.roots[0]!.id,
+        tool: "read_file",
+        arguments: { path: "marker.txt" },
+      });
+      expect(result).toMatchObject({ ok: true, value: { content: "from-computer-2" } });
+      await connection.closeSession(sessionId);
+    } finally {
+      handle?.stop();
+      if (handle) await handle.closed;
+      await server.stop(true);
+    }
+  }, 15_000);
+
+  test("refuses browser-origin pairing requests", async () => {
+    writeTestConfig(config());
+    const hub = new RemoteWorkspaceHub(new HubStore());
+    const server = startServer(0, {
+      managementAuthState: managementAuth(),
+      managementApi: { remoteWorkspaceHub: hub },
+    });
+    try {
+      const response = await fetch(new URL("/remote-workspace/pair", server.url), {
+        method: "POST",
+        headers: { origin: "https://evil.example", "content-type": "application/json" },
+        body: "{}",
+      });
+      expect(response.status).toBe(403);
+    } finally {
+      await server.stop(true);
+    }
+  });
+
+  test("rate-limits repeated pairing guesses before parsing more bodies and recovers after expiry", async () => {
+    writeTestConfig(config());
+    let now = Date.parse("2026-09-04T00:00:00.000Z");
+    const hub = new RemoteWorkspaceHub(new HubStore(), () => now);
+    const server = startServer(0, {
+      managementAuthState: managementAuth(),
+      managementApi: { remoteWorkspaceHub: hub },
+    });
+    const identity = generateRemoteControlIdentityKeyPair();
+    const body = {
+      code: "AAAA-BBBB-CCCC",
+      name: "Computer 2",
+      platform: "linux-x64",
+      publicKey: identity.publicKey,
+      roots: [{ id: crypto.randomUUID(), label: "Project" }],
+    };
+    try {
+      for (let attempt = 1; attempt < 10; attempt += 1) {
+        const response = await fetch(new URL("/remote-workspace/pair", server.url), {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            // None of these caller-controlled identities may choose a public-listener bucket.
+            "x-forwarded-for": `192.0.2.${attempt}`,
+            "cf-connecting-ip": `198.51.100.${attempt}`,
+            "tailscale-user-login": `spoof-${attempt}@example.test`,
+          },
+          body: JSON.stringify(body),
+        });
+        expect(response.status).toBe(401);
+      }
+      const limited = await fetch(new URL("/remote-workspace/pair", server.url), {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "x-forwarded-for": "203.0.113.250",
+          "cf-connecting-ip": "203.0.113.251",
+          "tailscale-user-login": "last-spoof@example.test",
+        },
+        body: JSON.stringify(body),
+      });
+      expect(limited.status).toBe(429);
+      expect(limited.headers.get("retry-after")).toBe("600");
+      expect(limited.headers.get("cache-control")).toBe("no-store");
+      expect(await limited.json()).toEqual({
+        error: "Remote Workspace pairing is temporarily rate limited.",
+      });
+
+      const blockedBeforeParse = await fetch(new URL("/remote-workspace/pair", server.url), {
+        method: "POST",
+        body: "not-json",
+      });
+      expect(blockedBeforeParse.status).toBe(429);
+
+      now += 10 * 60_000 + 1;
+      const grant = hub.createPairingGrant();
+      const paired = await fetch(new URL("/remote-workspace/pair", server.url), {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ ...body, code: grant.code }),
+      });
+      expect(paired.status).toBe(201);
+    } finally {
+      await server.stop(true);
+    }
+  });
+
+  test("does not let management-ingress callers rotate Tailscale headers around the peer bucket", async () => {
+    const managementPort = await findAvailablePort(0, "127.0.0.1");
+    writeTestConfig({
+      ...config(),
+      hub: {
+        managementPublicOrigin: "https://hub.example.test",
+        managementIngress: { enabled: true, port: managementPort },
+      },
+    });
+    const hub = new RemoteWorkspaceHub(new HubStore());
+    const server = startServer(0, {
+      managementAuthState: managementAuth(),
+      managementApi: { remoteWorkspaceHub: hub },
+    });
+    const body = JSON.stringify({
+      code: "AAAA-BBBB-CCCC",
+      name: "Computer 2",
+      platform: "linux-x64",
+      publicKey: generateRemoteControlIdentityKeyPair().publicKey,
+      roots: [{ id: crypto.randomUUID(), label: "Project" }],
+    });
+    const attempt = async (identity: string): Promise<Response> => await fetch(
+      `http://127.0.0.1:${managementPort}/remote-workspace/pair`,
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "tailscale-user-login": identity,
+        },
+        body,
+      },
+    );
+    try {
+      for (let count = 1; count < 10; count += 1) {
+        expect((await attempt(`rotated-${count}@example.test`)).status).toBe(401);
+      }
+      expect((await attempt("another-identity@example.test")).status).toBe(429);
+    } finally {
+      await server.stop(true);
+    }
+  });
+
+  test("unused Hub listener shutdown never activates Remote Workspace", async () => {
+    writeTestConfig(config());
+    const hub = new RemoteWorkspaceHub(new HubStore());
+    let stopCalls = 0;
+    const sessions = {
+      async shutdown() { stopCalls += 1; },
+    } as unknown as RemoteWorkspaceSessionService;
+    const server = startServer(0, {
+      managementAuthState: managementAuth(),
+      managementApi: { remoteWorkspaceHub: hub, remoteWorkspaceSessions: sessions },
+    });
+    await server.stop(true);
+    expect(stopCalls).toBe(0);
+  });
+
+  test("accepts a paired Executor through the loopback management-ingress WebSocket exception", async () => {
+    const managementPort = await findAvailablePort(0, "127.0.0.1");
+    writeTestConfig({
+      ...config(),
+      hub: {
+        managementPublicOrigin: "https://hub.example.test",
+        managementIngress: { enabled: true, port: managementPort },
+      },
+    });
+    const hub = new RemoteWorkspaceHub(new HubStore());
+    const server = startServer(0, {
+      managementAuthState: managementAuth(),
+      managementApi: { remoteWorkspaceHub: hub },
+    });
+    const workspace = join(root, "management-ingress-executor");
+    mkdirSync(workspace);
+    let handle: ReturnType<typeof connectRemoteWorkspaceAgent> | null = null;
+    try {
+      const grant = hub.createPairingGrant();
+      const state = await pairRemoteWorkspaceDevice({
+        hubUrl: `http://127.0.0.1:${managementPort}`,
+        pairingCode: grant.code,
+        roots: [{ path: workspace }],
+        store: new DeviceStore(),
+      });
+      handle = connectRemoteWorkspaceAgent({ state, commandRunner: null });
+      await handle.connected;
+      expect(hub.listDevices()[0]).toMatchObject({ online: true, capabilities: ["workspace.read", "workspace.write"] });
+    } finally {
+      handle?.stop();
+      if (handle) await handle.closed;
+      await server.stop(true);
+    }
+  }, 15_000);
+});
+
+test("server stop awaits workspace cleanup after management-only activation", async () => {
+  writeTestConfig(config());
+  const hub = new RemoteWorkspaceHub(new HubStore());
+  const auth = managementAuth();
+  let stopped = false;
+  const sessions = {
+    async availability() { return { codex: { available: false }, claude: { available: false }, pi: { available: false } }; },
+    list() { return []; },
+    async shutdown() { await Promise.resolve(); stopped = true; },
+  } as unknown as RemoteWorkspaceSessionService;
+  const server = startServer(0, {
+    managementAuthState: auth,
+    managementApi: { remoteWorkspaceHub: hub, remoteWorkspaceSessions: sessions },
+  });
+  try {
+    const response = await fetch(new URL("/api/remote-workspace", server.url), {
+      headers: { authorization: `Bearer ${auth.token}` },
+    });
+    expect(response.status).toBe(200);
+    expect(stopped).toBe(false);
+  } finally { await server.stop(true); }
+  expect(stopped).toBe(true);
+});
+
+test("pairing body completion after stop cannot consume the enrollment grant", async () => {
+  writeTestConfig(config());
+  const hub = new RemoteWorkspaceHub(new HubStore());
+  const grant = hub.createPairingGrant();
+  const payload = { code: grant.code, name: "Executor", platform: "test", publicKey: generateRemoteControlIdentityKeyPair().publicKey, roots: [{ id: crypto.randomUUID(), label: "Project" }] };
+  let admitted!: () => void;
+  const admission = new Promise<void>(resolve => { admitted = resolve; });
+  const original = hub.assertPairingSourceAllowed.bind(hub);
+  const spy = spyOn(hub, "assertPairingSourceAllowed").mockImplementation(source => { original(source); admitted(); });
+  let controller!: ReadableStreamDefaultController<Uint8Array>;
+  const body = new ReadableStream<Uint8Array>({ start(value) { controller = value; controller.enqueue(new TextEncoder().encode("{")); } });
+  const server = startServer(0, { managementAuthState: managementAuth(), managementApi: { remoteWorkspaceHub: hub } });
+  try {
+    const pending = fetch(new URL("/remote-workspace/pair", server.url), { method: "POST", headers: { "content-type": "application/json" }, body });
+    await admission;
+    const stopping = server.stop(false);
+    controller.enqueue(new TextEncoder().encode(JSON.stringify(payload).slice(1)));
+    controller.close();
+    const response = await pending;
+    expect(response.status).toBe(503);
+    await stopping;
+    expect(hub.listDevices()).toEqual([]);
+    expect(hub.pairDevice(payload).device.name).toBe("Executor");
+  } finally { spy.mockRestore(); await server.stop(true); }
+}, 15_000);
diff --git a/tests/clients/remote-workspace-sessions.test.ts b/tests/clients/remote-workspace-sessions.test.ts
index 45c6ed4f13..0d3e559069 100644
--- a/tests/clients/remote-workspace-sessions.test.ts
+++ b/tests/clients/remote-workspace-sessions.test.ts
@@ -51,10 +51,12 @@ function createHarness(options: {
   onAvailable?: () => void;
   deviceIds?: string[];
   onStart?: () => void;
+  onPrompt?: () => void;
   lazyResumable?: boolean;
   eventsAtStart?: number;
   sessionStore?: RemoteWorkspaceSessionStateStore;
   stopError?: Error;
+  onStop?: (call: number) => Promise<void>;
   closeError?: Error;
 } = {}): Harness {
   const deviceIds = options.deviceIds ?? [DEVICE_ID];
@@ -121,6 +123,7 @@ function createHarness(options: {
         canResume: () => runtimeResumable,
         async prompt() {
           promptStarted = true;
+          options.onPrompt?.();
           if (options.promptGate) await options.promptGate.promise;
           else {
             const response = await coordinator.handle({
@@ -141,6 +144,7 @@ function createHarness(options: {
         },
         async stop() {
           stops += 1;
+          await options.onStop?.(stops);
           if (promptStarted) options.promptGate?.reject(new Error("turn cancelled"));
           if (options.stopError) throw options.stopError;
         },
@@ -164,6 +168,62 @@ function createHarness(options: {
 }
 
 describe("Remote Workspace session service", () => {
+  test("accepted resumed turns stay busy through reconnect and runtime startup", async () => {
+    const store = new MemorySessionStore();
+    const first = createHarness({ sessionStore: store });
+    const created = await first.service.create({ profile: "codex", deviceId: DEVICE_ID, rootId: ROOT_ID });
+    await first.service.shutdown();
+    const startGate = deferred();
+    const started = deferred();
+    const promptGate = deferred();
+    const prompted = deferred();
+    const resumed = createHarness({ sessionStore: store, startGate, onStart: started.resolve, promptGate, onPrompt: prompted.resolve });
+    const accepted = resumed.service.submitPrompt(created.id, "Long turn");
+    expect(["starting", "running"]).toContain(accepted.status);
+    expect(accepted.events.at(-1)!.sequence).toBeGreaterThan(created.events.at(-1)!.sequence);
+    await started.promise;
+    expect(["starting", "running"]).toContain(resumed.service.get(created.id)!.status);
+    startGate.resolve();
+    await prompted.promise;
+    expect(resumed.service.get(created.id)!.status).toBe("running");
+    expect(() => resumed.service.submitPrompt(created.id, "Duplicate")).toThrow("active turn");
+    await resumed.service.stop(created.id);
+    expect(resumed.service.get(created.id)!.status).toBe("stopped");
+  });
+
+  test("a rejected accepted turn is observed and publishes a terminal failure", async () => {
+    const failed = deferred();
+    const store = new class extends MemorySessionStore {
+      override save(state: RemoteWorkspaceSessionState) {
+        super.save(state);
+        if (state.sessions.some(session => session.status === "failed")) failed.resolve();
+      }
+    }();
+    const gate = deferred();
+    const entered = deferred();
+    const harness = createHarness({ sessionStore: store, promptGate: gate, onPrompt: entered.resolve });
+    const created = await harness.service.create({ profile: "codex", deviceId: DEVICE_ID, rootId: ROOT_ID });
+    const accepted = harness.service.submitPrompt(created.id, "Will fail");
+    expect(accepted.status).toBe("running");
+    await entered.promise;
+    gate.reject(new Error("held turn failed"));
+    await failed.promise;
+    expect(harness.service.get(created.id)!.status).toBe("failed");
+    expect(harness.service.get(created.id)!.events.at(-1)!.text).toBe("held turn failed");
+    await harness.service.stop(created.id);
+  });
+
+  test("Stop immediately after acceptance prevents the model prompt", async () => {
+    let prompts = 0;
+    const harness = createHarness({ onPrompt: () => { prompts++; } });
+    const created = await harness.service.create({ profile: "codex", deviceId: DEVICE_ID, rootId: ROOT_ID });
+    harness.service.submitPrompt(created.id, "Cancel before execution");
+    await harness.service.stop(created.id);
+    expect(prompts).toBe(0);
+    expect(harness.stopCalls()).toBe(1);
+    expect(harness.service.get(created.id)!.status).toBe("stopped");
+  });
+
   for (const operation of ["create", "resume"] as const) {
     for (const scope of ["device", "global"] as const) {
       test(`${operation} reserves ${scope} capacity before awaiting runtime availability`, async () => {
@@ -207,6 +267,33 @@ describe("Remote Workspace session service", () => {
     }
   }
 
+  test.each(["stop", "shutdown"] as const)("%s reports failed cleanup of a late resumed runtime", async action => {
+    const store = new MemorySessionStore();
+    const first = createHarness({ sessionStore: store });
+    const created = await first.service.create({ profile: "codex", deviceId: DEVICE_ID, rootId: ROOT_ID });
+    await first.service.shutdown();
+    const gate = deferred();
+    const entered = deferred();
+    const cleanupError = new Error("late stop failed");
+    let modelPrompts = 0;
+    const resumed = createHarness({ sessionStore: store, startGate: gate, onStart: entered.resolve, stopError: cleanupError, onPrompt: () => { modelPrompts += 1; } });
+    const prompt = resumed.service.prompt(created.id, "Resume").then(() => "resolved", () => "rejected");
+    await entered.promise;
+    const stopping = action === "stop" ? resumed.service.stop(created.id) : resumed.service.shutdown();
+    const outcome = Promise.allSettled([stopping]);
+    gate.resolve();
+    const [result] = await outcome;
+    expect(result!.status).toBe("rejected");
+    if (result!.status !== "rejected") throw new Error("cleanup unexpectedly succeeded");
+    expect(result!.reason).toBe(cleanupError);
+    expect(modelPrompts).toBe(0);
+    expect(resumed.invocations).toEqual([]);
+    expect(await prompt).toBe("rejected");
+    expect(resumed.stopCalls()).toBe(1);
+    expect(resumed.closedSessions).toEqual([created.id]);
+    expect(resumed.service.get(created.id)?.status).toBe("failed");
+  });
+
   test("failed availability releases every pending runtime reservation", async () => {
     const gate = deferred();
     const harness = createHarness({ availableGate: gate });
@@ -433,3 +520,74 @@ test("read-only capability grant is forwarded on initial open and reconnect", as
   expect(harness.sessionGrants).toEqual([["workspace.read"], ["workspace.read"]]);
   await harness.service.stop(created.id);
 });
+
+
+test("availability completing after shutdown cannot create a new session", async () => {
+  const gate = deferred();
+  let started = false;
+  const service = new RemoteWorkspaceSessionService({} as RemoteWorkspaceHub, [{
+    profile: "codex",
+    async available() { await gate.promise; return { available: true }; },
+    async start() { started = true; throw new Error("must not start"); },
+  }]);
+  const outcome = service.create({ profile: "codex", deviceId: DEVICE_ID, rootId: ROOT_ID });
+  const rejection = Promise.allSettled([outcome]);
+  const stopping = service.shutdown();
+  gate.resolve();
+  await stopping;
+  const [result] = await rejection;
+  expect(result!.status).toBe("rejected");
+  if (result!.status !== "rejected") throw new Error("creation unexpectedly succeeded");
+  expect(result!.reason.message).toContain("stopping");
+  expect(started).toBe(false);
+  expect(service.list()).toEqual([]);
+});
+
+
+test("shutdown owns a runtime that finishes starting late", async () => {
+  const startGate = deferred();
+  const entered = deferred();
+  const harness = createHarness({ startGate, onStart: entered.resolve });
+  const creating = harness.service.create({ profile: "codex", deviceId: DEVICE_ID, rootId: ROOT_ID });
+  const rejection = Promise.allSettled([creating]);
+  await entered.promise;
+  let settled = false;
+  const stopping = harness.service.shutdown().then(() => { settled = true; });
+  await Promise.resolve();
+  await Promise.resolve();
+  expect(settled).toBe(false);
+  startGate.resolve();
+  await stopping;
+  const [result] = await rejection;
+  expect(result!.status).toBe("rejected");
+  if (result!.status !== "rejected") throw new Error("creation unexpectedly succeeded");
+  expect(result!.reason.message).toContain("stopped while starting");
+  expect(harness.stopCalls()).toBe(1);
+  expect(settled).toBe(true);
+});
+
+
+test("shutdown settles every session before propagating a cleanup failure", async () => {
+  const heldStop = deferred();
+  const secondEntered = deferred();
+  const harness = createHarness({
+    async onStop(call) {
+      if (call === 1) throw new Error("first cleanup failed");
+      secondEntered.resolve();
+      await heldStop.promise;
+    },
+  });
+  await harness.service.create({ profile: "codex", deviceId: DEVICE_ID, rootId: ROOT_ID });
+  await harness.service.create({ profile: "codex", deviceId: DEVICE_ID, rootId: ROOT_ID });
+  let settled = false;
+  const stopping = harness.service.shutdown().then(
+    () => { settled = true; return "unexpected success"; },
+    error => { settled = true; return (error as Error).message; },
+  );
+  await secondEntered.promise;
+  await Promise.resolve();
+  expect(settled).toBe(false);
+  heldStop.resolve();
+  expect(await stopping).toBe("first cleanup failed");
+  expect(harness.stopCalls()).toBe(2);
+});
diff --git a/tests/clients/remote-workspace.test.ts b/tests/clients/remote-workspace.test.ts
index feeb2b08ce..a639c848f8 100644
--- a/tests/clients/remote-workspace.test.ts
+++ b/tests/clients/remote-workspace.test.ts
@@ -6,6 +6,7 @@ import {
   linkSync,
   mkdtempSync,
   readFileSync,
+  realpathSync,
   renameSync,
   symlinkSync,
   writeFileSync,
@@ -39,7 +40,12 @@ const localTestCommandRunner: RemoteWorkspaceCommandRunner = {
   async run(request) {
     const child = Bun.spawn(request.command, {
       cwd: request.cwd,
-      env: { PATH: process.env.PATH ?? "/usr/bin:/bin", LANG: "C.UTF-8", HOME: request.cwd },
+      env: {
+        PATH: process.env.PATH ?? "/usr/bin:/bin", LANG: "C.UTF-8", HOME: request.cwd,
+        ...(process.platform === "win32" ? Object.fromEntries(
+          ["SystemRoot", "WINDIR", "TEMP", "TMP"].flatMap(name => process.env[name] ? [[name, process.env[name]!]] : []),
+        ) : {}),
+      },
       stdin: "ignore",
       stdout: "pipe",
       stderr: "pipe",
@@ -233,9 +239,7 @@ describe("remote workspace coordinator and executor", () => {
     expect(readFileSync(join(state.executorRoot, "project", "marker.txt"), "utf8")).toBe("executor-after");
     expect(readFileSync(join(state.main, "project", "marker.txt"), "utf8")).toBe("main-only");
 
-    const command = process.platform === "win32"
-      ? ["powershell.exe", "-NoProfile", "-Command", "Write-Output -NoNewline 'executor-process:'; (Get-Location).Path"]
-      : ["/bin/sh", "-lc", "printf 'executor-process:'; pwd"];
+    const command = [process.execPath, "--eval", "process.stdout.write('executor-process:' + process.cwd())"];
     const exec = await state.coordinator.handle(state.request("exec", {
       command,
       cwd: "project",
@@ -244,9 +248,12 @@ describe("remote workspace coordinator and executor", () => {
     const result = responseValue(exec);
     expect(exec.result.success).toBe(true);
     expect(result.ok).toBe(true);
-    expect(JSON.stringify(result.value)).toContain("executor-process:");
-    expect(JSON.stringify(result.value)).toContain(join(state.executorRoot, "project"));
-    expect(JSON.stringify(result.value)).not.toContain(state.main);
+    expect(result).toMatchObject({
+      ok: true,
+      value: { exitCode: 0, stderr: "", stdout: `executor-process:${realpathSync(join(state.executorRoot, "project"))}` },
+    });
+    const output = result.value as { stdout: string };
+    expect(output.stdout).not.toContain(realpathSync(state.main));
   });
 
   test("lists and reads bounded workspace data through the selected root", async () => {
diff --git a/tests/fixtures/test-layout-expected.json b/tests/fixtures/test-layout-expected.json
index 47c0eb59c6..a11370a88f 100644
--- a/tests/fixtures/test-layout-expected.json
+++ b/tests/fixtures/test-layout-expected.json
@@ -895,6 +895,9 @@
   "release-notes.test.ts": "ci-workflows",
   "release-version-line.test.ts": "ci-workflows",
   "remote-catalog.test.ts": "clients",
+  "remote-workspace-activation.test.ts": "clients",
+  "remote-workspace-management.test.ts": "clients",
+  "remote-workspace-server.test.ts": "clients",
   "remote-workspace-secret-store.test.ts": "clients",
   "remote-workspace-session-binding.test.ts": "clients",
   "remote-workspace-agent-wire.test.ts": "clients",
diff --git a/tests/server/loopback-listener-integration.test.ts b/tests/server/loopback-listener-integration.test.ts
index 3b616d822e..8ebadc969f 100644
--- a/tests/server/loopback-listener-integration.test.ts
+++ b/tests/server/loopback-listener-integration.test.ts
@@ -782,6 +782,17 @@ describe("unauthenticated loopback listener", () => {
 });
 
 describe("composite listener shutdown", () => {
+  test("starts socket-owner cleanup before waiting for a graceful listener drain", async () => {
+    const ran: string[] = [];
+    let release!: () => void;
+    const closed = new Promise<void>(resolve => { release = resolve; });
+    await runListenerShutdown([
+      async () => { ran.push("admission-closed"); await closed; ran.push("drained"); },
+      async () => { ran.push("owner-cleanup"); release(); },
+    ], async () => { ran.push("lifecycle"); });
+    expect(ran).toEqual(["admission-closed", "owner-cleanup", "drained", "lifecycle"]);
+  });
+
   // Both listeners share one `stop`, and the two properties it must hold pull against each
   // other: keep cleaning up after a failure, yet still report that failure. A test against a
   // live server cannot inject the rejection, so the orchestration was extracted.
@@ -844,7 +855,7 @@ describe("seams the runtime cannot defend", () => {
     // issued from a sibling Bun.serve in the same process. Another version or platform is not
     // promised to, and the loopback listener would then fail to upgrade at all.
     expect(serverSource).not.toMatch(/\bif \(server\.upgrade\(req,/);
-    expect(serverSource.match(/requestServer\.upgrade\(req,/g)?.length).toBe(2);
+    expect(serverSource.match(/requestServer\.upgrade\(req,/g)?.length).toBe(3);
   });
 
   test("the loopback listener binds 127.0.0.1 explicitly", () => {