diff --git a/console/index.html b/console/index.html
index b2f33a9..f762355 100644
--- a/console/index.html
+++ b/console/index.html
@@ -21,7 +21,7 @@
       <section id="config" class="config-wrap"></section>
       <section id="config-editor" class="cfg-editor-wrap" hidden>
         <div class="cfg-editor-head">
-          <span class="cfg-label">edit fleets.toml</span>
+          <span class="cfg-label" id="cfg-editor-title">edit fleets.toml</span>
           <span class="cfg-editor-path" id="cfg-editor-path"></span>
           <span class="cfg-editor-spacer"></span>
           <button class="cfg-btn" id="cfg-save" type="button">Save</button>
@@ -31,6 +31,7 @@
         <div class="cfg-editor-error" id="cfg-editor-error" hidden></div>
       </section>
       <section id="identity" class="identity-wrap"></section>
+      <section id="remote" class="remote-wrap"></section>
       <section class="logs">
         <nav class="tabs" id="tabs">
           <button class="tab is-active" data-target="log">Activity</button>
diff --git a/console/src/fixtures.ts b/console/src/fixtures.ts
index 86773b7..f7c4500 100644
--- a/console/src/fixtures.ts
+++ b/console/src/fixtures.ts
@@ -1,4 +1,24 @@
-import type { Deployment, FleetConfig, RuntimeContext } from "./types";
+import type {
+  Deployment,
+  FleetConfig,
+  RemoteConfig,
+  RuntimeContext,
+} from "./types";
+
+// Stand-in remote-connection view so the browser build renders the remote panel
+// without a core. A configured-but-disconnected example — the shape the panel
+// shows before the operator hits "Activate".
+export const FIXTURE_REMOTE_CONFIG: RemoteConfig = {
+  path: "~/.config/oab-studio/remote.toml",
+  text: `# OAB Studio — remote reverse-MCP connection (the /acp endpoint Studio dials)
+url = "wss://gateway.example/acp"
+token = "…"
+cwd = "/"
+`,
+  url: "wss://gateway.example/acp",
+  configured: true,
+  status: "disconnected",
+};
 
 // Stand-in data so the console renders without a live core. Mirrors the shape
 // studio-cp's `deploy_list` / `deploy_get` return. Swapped for the Tauri source
diff --git a/console/src/main.ts b/console/src/main.ts
index 51d9071..4f379a8 100644
--- a/console/src/main.ts
+++ b/console/src/main.ts
@@ -3,9 +3,10 @@ import {
   renderRoster,
   renderIdentity,
   renderFleetConfig,
+  renderRemote,
   filterByMembers,
 } from "./render";
-import type { FleetConfig } from "./types";
+import type { FleetConfig, RemoteConfig } from "./types";
 import { createPane, bindBackend, type Level } from "./log";
 import { EditorView, basicSetup } from "codemirror";
 import { EditorState } from "@codemirror/state";
@@ -25,14 +26,17 @@ let activeFleet: string | null = null;
 let activeCluster = DEFAULT_CLUSTER;
 let activeMembers: string[] = [];
 let fleetConfig: FleetConfig | null = null;
+let remoteConfig: RemoteConfig | null = null;
 
 const roster = document.getElementById("roster");
 const identityEl = document.getElementById("identity");
 const configEl = document.getElementById("config");
+const remoteEl = document.getElementById("remote");
 const editorSection = document.getElementById("config-editor");
 const editorMount = document.getElementById("cfg-editor-mount");
 const editorError = document.getElementById("cfg-editor-error");
 const editorPathEl = document.getElementById("cfg-editor-path");
+const editorTitleEl = document.getElementById("cfg-editor-title");
 const saveBtn = document.getElementById("cfg-save") as HTMLButtonElement | null;
 const cancelBtn = document.getElementById("cfg-cancel") as HTMLButtonElement | null;
 const clusterLabel = document.getElementById("cluster-label");
@@ -147,6 +151,21 @@ async function refreshConfig(): Promise<void> {
   }
 }
 
+// The remote reverse-MCP connection panel (Part B). Fetched on boot; the live
+// status is also pushed via the `remote-status` event (see boot), so this is the
+// initial render + a refresh after an activate/deactivate/save action.
+async function refreshRemote(): Promise<void> {
+  if (!remoteEl) return;
+  try {
+    remoteConfig = await source.remoteConfig();
+    renderRemote(remoteEl, remoteConfig);
+  } catch (e) {
+    note("error", `remote config: ${errText(e)}`);
+    remoteConfig = null;
+    renderRemote(remoteEl, null);
+  }
+}
+
 // Switch the active fleet by identity (name): re-point every read at its cluster
 // (and thus its bound credential), filter the roster to its members, and refresh
 // immediately — so "switch fleet" == "switch managing account + roster" the ADR
@@ -166,11 +185,13 @@ function selectFleet(name: string): void {
   void tick();
 }
 
-// ---- fleets.toml editor (ADR #19 slice C: the "edit" side) -------------------
-// A CodeMirror TOML editor over the raw config file. Kept imperative (CM owns
-// real DOM) and separate from the re-rendered config panel, so switching fleets
-// never wipes an open editor.
+// ---- TOML editor (fleets.toml + remote.toml) ---------------------------------
+// One CodeMirror TOML editor, shared by both config files (which one is set by
+// `editorTarget`). Kept imperative (CM owns real DOM) and separate from the
+// re-rendered panels, so a background refresh never wipes an open editor.
+type EditorTarget = "fleet" | "remote";
 let editorView: EditorView | null = null;
+let editorTarget: EditorTarget = "fleet";
 
 function showEditorError(msg: string | null): void {
   if (!editorError) return;
@@ -178,15 +199,21 @@ function showEditorError(msg: string | null): void {
   editorError.hidden = !msg;
 }
 
-function openEditor(): void {
+function openEditor(target: EditorTarget): void {
   if (!editorSection || !editorMount) return;
+  editorTarget = target;
+  const isRemote = target === "remote";
+  const doc = (isRemote ? remoteConfig?.text : fleetConfig?.text) ?? "";
+  const path = (isRemote ? remoteConfig?.path : fleetConfig?.path) ?? "";
   showEditorError(null);
-  if (editorPathEl) editorPathEl.textContent = fleetConfig?.path ?? "";
+  if (editorTitleEl)
+    editorTitleEl.textContent = isRemote ? "edit remote.toml" : "edit fleets.toml";
+  if (editorPathEl) editorPathEl.textContent = path;
   editorView?.destroy();
   editorView = new EditorView({
     parent: editorMount,
     state: EditorState.create({
-      doc: fleetConfig?.text ?? "",
+      doc,
       extensions: [basicSetup, StreamLanguage.define(toml)],
     }),
   });
@@ -208,12 +235,19 @@ async function saveEditor(): Promise<void> {
   showEditorError(null);
   try {
     // The backend validates the TOML and rejects (without writing) on error.
-    fleetConfig = await source.writeFleetConfig(text);
-    if (configEl) renderFleetConfig(configEl, fleetConfig, activeFleet);
-    note("info", "fleet config saved");
-    closeEditor();
-    // A binding change may alter the active fleet's credential — re-observe.
-    void refreshIdentity();
+    if (editorTarget === "remote") {
+      remoteConfig = await source.writeRemoteConfig(text);
+      if (remoteEl) renderRemote(remoteEl, remoteConfig);
+      note("info", "remote config saved");
+      closeEditor();
+    } else {
+      fleetConfig = await source.writeFleetConfig(text);
+      if (configEl) renderFleetConfig(configEl, fleetConfig, activeFleet);
+      note("info", "fleet config saved");
+      closeEditor();
+      // A binding change may alter the active fleet's credential — re-observe.
+      void refreshIdentity();
+    }
   } catch (e) {
     showEditorError(`save failed — ${errText(e)}`);
   } finally {
@@ -230,7 +264,7 @@ if (configEl) {
   configEl.addEventListener("click", (ev) => {
     const target = ev.target as HTMLElement;
     if (target.closest('[data-action="edit-config"]')) {
-      openEditor();
+      openEditor("fleet");
       return;
     }
     const btn = target.closest<HTMLElement>("[data-fleet]");
@@ -238,6 +272,37 @@ if (configEl) {
   });
 }
 
+// The remote panel: "Edit config" opens remote.toml in the editor; "Activate"
+// dials the /acp endpoint; "Disconnect" tears it down. Status then updates via
+// the `remote-status` event, with a refresh as a fallback.
+async function remoteAction(kind: "connect" | "disconnect"): Promise<void> {
+  try {
+    if (kind === "connect") {
+      await source.remoteConnect();
+      note("info", "activating remote connection…");
+    } else {
+      await source.remoteDisconnect();
+      note("info", "remote connection deactivated");
+    }
+  } catch (e) {
+    note("error", `remote ${kind}: ${errText(e)}`);
+  }
+  void refreshRemote();
+}
+
+if (remoteEl) {
+  remoteEl.addEventListener("click", (ev) => {
+    const target = ev.target as HTMLElement;
+    if (target.closest('[data-action="edit-remote-config"]')) {
+      openEditor("remote");
+    } else if (target.closest('[data-action="remote-connect"]')) {
+      void remoteAction("connect");
+    } else if (target.closest('[data-action="remote-disconnect"]')) {
+      void remoteAction("disconnect");
+    }
+  });
+}
+
 // ---- start / stop (ADR-2 write model: stop = scale→0, start = scale→1) -------
 // Scale a deployment off (0) or on (1). Reversible — ECS keeps the Spec at
 // desiredCount 0 — so this needs no state store. On success `tick()` re-renders
@@ -369,17 +434,43 @@ function setupUpdater(): void {
   el.addEventListener("click", () => void (pending ? install(el, invoke) : check(el, invoke)));
 }
 
+// Live remote-connection status: the backend pushes `remote-status` events as the
+// transport connects / drops / errors, so the panel reflects the real state
+// without polling. Browser build (no `__TAURI__`) simply skips it.
+async function bindRemoteStatus(): Promise<void> {
+  interface EventGlobal {
+    event?: {
+      listen?: <T>(
+        e: string,
+        h: (e: { payload: T }) => void,
+      ) => Promise<unknown>;
+    };
+  }
+  const listen = (globalThis as { __TAURI__?: EventGlobal }).__TAURI__?.event
+    ?.listen;
+  if (!listen) return;
+  await listen<{ status: string }>("remote-status", (e) => {
+    const status = e.payload?.status ?? "disconnected";
+    if (remoteConfig) {
+      remoteConfig = { ...remoteConfig, status };
+      if (remoteEl) renderRemote(remoteEl, remoteConfig);
+    }
+  });
+}
+
 // Boot order matters: subscribe to the log streams FIRST, then start the core,
 // so the spawn → handshake → ready lifecycle lines are captured, not lost.
 async function boot(): Promise<void> {
   note("info", `OAB Studio ${BUILD} (built ${__BUILD_TIME__})`);
   if (activity && mcp) await bindBackend(activity, mcp);
+  await bindRemoteStatus();
   if (clusterLabel) clusterLabel.textContent = activeCluster;
   note("info", `polling cluster "${activeCluster}" every ${POLL_MS / 1000}s`);
   setupUpdater();
   await startCore();
   void refreshConfig();
   void refreshIdentity();
+  void refreshRemote();
   void tick();
   window.setInterval(() => void tick(), POLL_MS);
 }
diff --git a/console/src/render.test.ts b/console/src/render.test.ts
index c2f2d5a..ae8b78e 100644
--- a/console/src/render.test.ts
+++ b/console/src/render.test.ts
@@ -3,12 +3,14 @@ import {
   rosterHtml,
   identityHtml,
   fleetConfigHtml,
+  remoteHtml,
   filterByMembers,
   serviceName,
 } from "./render";
 import {
   FIXTURE_DEPLOYMENTS,
   FIXTURE_FLEET_CONFIG,
+  FIXTURE_REMOTE_CONFIG,
   FIXTURE_RUNTIME_CONTEXT,
 } from "./fixtures";
 import { AGENT_STATES, type Deployment, type RuntimeContext } from "./types";
@@ -238,6 +240,63 @@ describe("fleetConfigHtml", () => {
   });
 });
 
+describe("remoteHtml", () => {
+  it("shows the endpoint and an Activate button when configured + disconnected", () => {
+    const html = remoteHtml(FIXTURE_REMOTE_CONFIG);
+    expect(html).toContain("wss://gateway.example/acp");
+    expect(html).toContain('data-action="remote-connect"');
+    expect(html).toContain("Activate remote connection");
+    expect(html).not.toContain("disabled");
+    // status badge reflects the state
+    expect(html).toContain("rm-disconnected");
+  });
+
+  it("disables Activate until url + token are configured", () => {
+    const html = remoteHtml({
+      ...FIXTURE_REMOTE_CONFIG,
+      configured: false,
+      url: "",
+    });
+    expect(html).toContain('data-action="remote-connect"');
+    expect(html).toContain("disabled");
+    expect(html).toContain("not configured");
+  });
+
+  it("shows Disconnect (not Activate) while connected", () => {
+    const html = remoteHtml({ ...FIXTURE_REMOTE_CONFIG, status: "connected" });
+    expect(html).toContain('data-action="remote-disconnect"');
+    expect(html).toContain("rm-connected");
+    expect(html).not.toContain('data-action="remote-connect"');
+  });
+
+  it("marks an error status", () => {
+    const html = remoteHtml({
+      ...FIXTURE_REMOTE_CONFIG,
+      status: "error: dial refused",
+    });
+    expect(html).toContain("rm-error");
+    expect(html).toContain("error: dial refused");
+    // an error is not "live", so it offers Activate again
+    expect(html).toContain('data-action="remote-connect"');
+  });
+
+  it("always offers Edit config", () => {
+    expect(remoteHtml(FIXTURE_REMOTE_CONFIG)).toContain(
+      'data-action="edit-remote-config"',
+    );
+  });
+
+  it("renders an unavailable state for null", () => {
+    expect(remoteHtml(null)).toContain("remote connection unavailable");
+  });
+
+  it("escapes the url", () => {
+    const html = remoteHtml({ ...FIXTURE_REMOTE_CONFIG, url: "wss://<x>/acp" });
+    expect(html).toContain("&lt;x&gt;");
+    expect(html).not.toContain("<x>/acp");
+  });
+});
+
 describe("filterByMembers", () => {
   it("keeps only deployments whose ECS service name is a member", () => {
     const kept = filterByMembers(FIXTURE_DEPLOYMENTS, ["oab-prod-orca"]);
diff --git a/console/src/render.ts b/console/src/render.ts
index da6ca41..46bc4c4 100644
--- a/console/src/render.ts
+++ b/console/src/render.ts
@@ -2,6 +2,7 @@ import type {
   AgentState,
   Deployment,
   FleetConfig,
+  RemoteConfig,
   RuntimeContext,
 } from "./types";
 
@@ -227,3 +228,56 @@ export function renderFleetConfig(
 ): void {
   el.innerHTML = fleetConfigHtml(cfg, activeFleet);
 }
+
+// ---- Remote reverse-MCP connection panel (Part B) ---------------------------
+// The "activate the remote connection" surface: the /acp endpoint, live status,
+// an explicit Activate/Disconnect button, and Edit config (the same editor as
+// fleets.toml, over remote.toml).
+
+const REMOTE_STATUS_CLASS: Record<string, string> = {
+  connected: "rm-connected",
+  connecting: "rm-connecting",
+  disconnected: "rm-disconnected",
+  error: "rm-error",
+};
+
+function remoteStatusBadge(status: string): string {
+  const key = status.startsWith("error") ? "error" : status;
+  const cls = REMOTE_STATUS_CLASS[key] ?? "rm-disconnected";
+  return `<span class="rm-status ${cls}">${escapeHtml(status || "disconnected")}</span>`;
+}
+
+// Pure: the remote-connection view -> the panel HTML. `null` renders an
+// unavailable state. The button is Disconnect while connected/connecting, else
+// Activate — disabled until a URL + token are configured.
+export function remoteHtml(view: RemoteConfig | null): string {
+  if (!view) {
+    return `<div class="remote"><span class="muted">remote connection unavailable</span></div>`;
+  }
+  const live = view.status === "connected" || view.status === "connecting";
+  const action = live
+    ? `<button class="rm-btn rm-disconnect" type="button" data-action="remote-disconnect">Disconnect</button>`
+    : `<button class="rm-btn rm-connect" type="button" data-action="remote-connect"${view.configured ? "" : " disabled"}>Activate remote connection</button>`;
+  const target = view.configured
+    ? `<code class="rm-url">${escapeHtml(view.url)}</code>`
+    : `<span class="muted">not configured — set <code>url</code> + <code>token</code> in the config</span>`;
+  const path = view.path
+    ? `<span class="cfg-path" title="edit this file to configure the remote connection"><code>${escapeHtml(view.path)}</code></span>`
+    : "";
+  return `<div class="remote">
+      <div class="rm-head">
+        <span class="cfg-label">remote</span>
+        ${path}
+        <button class="cfg-edit" type="button" data-action="edit-remote-config">Edit config</button>
+      </div>
+      <div class="rm-body">
+        ${remoteStatusBadge(view.status)}
+        <span class="rm-target">${target}</span>
+        ${action}
+      </div>
+    </div>`;
+}
+
+export function renderRemote(el: HTMLElement, view: RemoteConfig | null): void {
+  el.innerHTML = remoteHtml(view);
+}
diff --git a/console/src/source.ts b/console/src/source.ts
index f7c1f0b..0c5ee4a 100644
--- a/console/src/source.ts
+++ b/console/src/source.ts
@@ -1,7 +1,13 @@
-import type { Deployment, FleetConfig, RuntimeContext } from "./types";
+import type {
+  Deployment,
+  FleetConfig,
+  RemoteConfig,
+  RuntimeContext,
+} from "./types";
 import {
   FIXTURE_DEPLOYMENTS,
   FIXTURE_FLEET_CONFIG,
+  FIXTURE_REMOTE_CONFIG,
   FIXTURE_RUNTIME_CONTEXT,
 } from "./fixtures";
 
@@ -24,6 +30,12 @@ export interface Source {
     namespace: string,
     cluster?: string,
   ): Promise<void>;
+  // The remote reverse-MCP connection (Part B): its config/status, the raw
+  // `remote.toml` for the editor, and the explicit activate/deactivate actions.
+  remoteConfig(): Promise<RemoteConfig>;
+  writeRemoteConfig(text: string): Promise<RemoteConfig>;
+  remoteConnect(): Promise<void>;
+  remoteDisconnect(): Promise<void>;
 }
 
 // Fixture-backed source for the standalone / browser build — no core required.
@@ -45,6 +57,15 @@ export class MockSource implements Source {
   // Browser preview: no core, so scaling is a no-op — the fixture roster is
   // re-cloned each poll, so nothing would persist anyway.
   async scaleDeployment(): Promise<void> {}
+  async remoteConfig(): Promise<RemoteConfig> {
+    return structuredClone(FIXTURE_REMOTE_CONFIG);
+  }
+  async writeRemoteConfig(text: string): Promise<RemoteConfig> {
+    return { ...structuredClone(FIXTURE_REMOTE_CONFIG), text };
+  }
+  // Browser preview: no core to dial, so activate/deactivate are no-ops.
+  async remoteConnect(): Promise<void> {}
+  async remoteDisconnect(): Promise<void> {}
 }
 
 // Minimal shape of the Tauri global bridge (v2, `withGlobalTauri`). Accessed via
@@ -91,6 +112,18 @@ export class TauriSource implements Source {
       cluster,
     });
   }
+  async remoteConfig(): Promise<RemoteConfig> {
+    return this.invoke()<RemoteConfig>("remote_config");
+  }
+  async writeRemoteConfig(text: string): Promise<RemoteConfig> {
+    return this.invoke()<RemoteConfig>("remote_config_write", { text });
+  }
+  async remoteConnect(): Promise<void> {
+    await this.invoke()<unknown>("remote_connect");
+  }
+  async remoteDisconnect(): Promise<void> {
+    await this.invoke()<unknown>("remote_disconnect");
+  }
 }
 
 // Pick a source: Tauri when running inside the shell, else the mock.
diff --git a/console/src/styles.css b/console/src/styles.css
index 1fef15f..2329f72 100644
--- a/console/src/styles.css
+++ b/console/src/styles.css
@@ -553,3 +553,80 @@ button.act:disabled {
   font-size: 12px;
   white-space: pre-wrap;
 }
+
+/* ---- Remote reverse-MCP connection panel (Part B) ---- */
+.remote-wrap {
+  margin: 0 0 12px;
+}
+.remote {
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  background: var(--panel);
+  padding: 10px 12px;
+  font-size: 13px;
+}
+.rm-head {
+  display: flex;
+  align-items: baseline;
+  gap: 10px;
+  margin-bottom: 8px;
+}
+.rm-body {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  flex-wrap: wrap;
+}
+.rm-status {
+  border-radius: 999px;
+  padding: 2px 10px;
+  font-size: 12px;
+  font-weight: 600;
+  color: #fff;
+  white-space: nowrap;
+}
+.rm-connected {
+  background: var(--s-running);
+}
+.rm-connecting {
+  background: var(--s-starting);
+}
+.rm-disconnected {
+  background: var(--s-stopped);
+}
+.rm-error {
+  background: var(--s-unhealthy);
+}
+.rm-target {
+  color: var(--muted);
+  overflow-wrap: anywhere;
+  flex: 1 1 auto;
+  min-width: 0;
+}
+.rm-url {
+  font-size: 12px;
+}
+.rm-btn {
+  cursor: pointer;
+  border: 1px solid var(--border);
+  border-radius: 5px;
+  background: var(--bg);
+  color: var(--text);
+  font: inherit;
+  font-size: 12px;
+  padding: 4px 12px;
+  white-space: nowrap;
+}
+.rm-connect {
+  border-color: var(--s-starting);
+  color: #fff;
+  background: var(--s-starting);
+}
+.rm-btn:disabled {
+  opacity: 0.5;
+  cursor: default;
+}
+.rm-disconnect:hover {
+  border-color: var(--s-unhealthy);
+  color: var(--s-unhealthy);
+}
diff --git a/console/src/types.ts b/console/src/types.ts
index e1da3b1..82cd942 100644
--- a/console/src/types.ts
+++ b/console/src/types.ts
@@ -72,6 +72,18 @@ export interface FleetConfig {
   text: string;
 }
 
+// The remote reverse-MCP connection view — mirrors src-tauri's `remote_config`
+// command (reverse-MCP client ADR, Part B). `path`/`text` back the in-app editor
+// for `remote.toml`; `url` + `configured` drive the panel; `status` is the live
+// connection state (`disconnected` | `connecting` | `connected` | `error: …`).
+export interface RemoteConfig {
+  path: string;
+  text: string;
+  url: string;
+  configured: boolean;
+  status: string;
+}
+
 // The effective runtime identity/context the control plane resolved for a
 // cluster — mirrors oab-mcp's `runtime_context` tool (ADR #19). `identity_matches`
 // is `null` when the binding declares no `expected_principal`.
diff --git a/crates/acp-tunnel/Cargo.toml b/crates/acp-tunnel/Cargo.toml
index 976b4f7..c1a63b8 100644
--- a/crates/acp-tunnel/Cargo.toml
+++ b/crates/acp-tunnel/Cargo.toml
@@ -8,3 +8,4 @@ license = "MIT"
 [dependencies]
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
+toml = "0.8"
diff --git a/crates/acp-tunnel/src/config.rs b/crates/acp-tunnel/src/config.rs
new file mode 100644
index 0000000..620e8d1
--- /dev/null
+++ b/crates/acp-tunnel/src/config.rs
@@ -0,0 +1,155 @@
+//! The reverse-MCP **remote-connection config** — the `/acp` endpoint Studio
+//! dials to attach to an agent runtime (reverse-MCP client ADR §5).
+//!
+//! Stored as a TOML file the operator can **edit in-app** (the same editor
+//! pattern as `fleets.toml`), at `~/.config/oab-studio/remote.toml`. Parsing,
+//! serialization, and validation are pure (here); the file IO + the actual dial
+//! live in the transport (`src-tauri`).
+//!
+//! ⚠️ The `token` is a `/acp` bearer — a **secret** that lives in this file. The
+//! app surfaces it in the editor (like any editable config) but must never log
+//! it. Prefer the loopback/keyless posture when the gateway allows it.
+
+use serde::{Deserialize, Serialize};
+
+fn default_cwd() -> String {
+    "/".to_string()
+}
+
+/// The declarative remote-connection config. All fields default to empty so a
+/// partial / not-yet-configured file still parses (the app shows it as
+/// "not configured" rather than erroring).
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct RemoteConfig {
+    /// The `/acp` WSS endpoint (e.g. `wss://gateway.example/acp`).
+    #[serde(default)]
+    pub url: String,
+    /// The `/acp` bearer token (secret; rides the WS sub-protocol on dial).
+    #[serde(default)]
+    pub token: String,
+    /// The session `cwd` sent on `session/new` (defaults to `/`).
+    #[serde(default = "default_cwd")]
+    pub cwd: String,
+}
+
+impl Default for RemoteConfig {
+    fn default() -> Self {
+        RemoteConfig {
+            url: String::new(),
+            token: String::new(),
+            cwd: default_cwd(),
+        }
+    }
+}
+
+impl RemoteConfig {
+    /// Parse from the TOML file text. An empty file yields the default (empty)
+    /// config rather than an error, so a fresh install is "not configured".
+    pub fn parse(text: &str) -> Result<Self, toml::de::Error> {
+        toml::from_str(text)
+    }
+
+    /// Serialize to TOML for writing the file back (round-trips the fields; the
+    /// editor holds the operator's raw text, so this is only used when the app
+    /// writes structured changes rather than raw text).
+    pub fn to_toml(&self) -> String {
+        toml::to_string_pretty(self).unwrap_or_default()
+    }
+
+    /// Whether enough is set to attempt a connection: a URL **and** a token.
+    /// (Drives whether the "Activate" button is enabled.)
+    pub fn is_configured(&self) -> bool {
+        !self.url.trim().is_empty() && !self.token.trim().is_empty()
+    }
+
+    /// Validate before dialing. Checks the URL is present and a WebSocket scheme;
+    /// a bad edit is rejected **without** connecting (mirroring how the fleet
+    /// config editor rejects bad TOML without writing). The token's validity is
+    /// only knowable at the handshake, so it is not checked here beyond presence.
+    pub fn validate(&self) -> Result<(), String> {
+        let url = self.url.trim();
+        if url.is_empty() {
+            return Err("url is required (the /acp WSS endpoint)".to_string());
+        }
+        if !(url.starts_with("ws://") || url.starts_with("wss://")) {
+            return Err(format!(
+                "url must be a WebSocket endpoint (ws:// or wss://), got {url:?}"
+            ));
+        }
+        if self.token.trim().is_empty() {
+            return Err("token is required (the /acp bearer)".to_string());
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_a_full_config() {
+        let cfg = RemoteConfig::parse(
+            r#"
+url = "wss://gw.example/acp"
+token = "sekret"
+cwd = "/work"
+"#,
+        )
+        .expect("parse");
+        assert_eq!(cfg.url, "wss://gw.example/acp");
+        assert_eq!(cfg.token, "sekret");
+        assert_eq!(cfg.cwd, "/work");
+        assert!(cfg.is_configured());
+        assert!(cfg.validate().is_ok());
+    }
+
+    #[test]
+    fn empty_file_is_the_default_not_configured() {
+        let cfg = RemoteConfig::parse("").expect("empty parses");
+        assert_eq!(cfg, RemoteConfig::default());
+        assert_eq!(cfg.cwd, "/"); // cwd defaults even when absent
+        assert!(!cfg.is_configured());
+        assert!(cfg.validate().is_err());
+    }
+
+    #[test]
+    fn cwd_defaults_when_omitted() {
+        let cfg = RemoteConfig::parse(r#"url = "wss://x/acp"
+token = "t""#)
+            .expect("parse");
+        assert_eq!(cfg.cwd, "/");
+    }
+
+    #[test]
+    fn validate_rejects_missing_url_bad_scheme_and_missing_token() {
+        assert!(RemoteConfig { url: "".into(), token: "t".into(), cwd: "/".into() }
+            .validate()
+            .is_err());
+        assert!(RemoteConfig {
+            url: "http://x/acp".into(),
+            token: "t".into(),
+            cwd: "/".into()
+        }
+        .validate()
+        .unwrap_err()
+        .contains("WebSocket"));
+        assert!(RemoteConfig {
+            url: "wss://x/acp".into(),
+            token: "".into(),
+            cwd: "/".into()
+        }
+        .validate()
+        .is_err());
+    }
+
+    #[test]
+    fn to_toml_round_trips() {
+        let cfg = RemoteConfig {
+            url: "wss://x/acp".into(),
+            token: "t".into(),
+            cwd: "/w".into(),
+        };
+        assert_eq!(RemoteConfig::parse(&cfg.to_toml()).unwrap(), cfg);
+    }
+}
diff --git a/crates/acp-tunnel/src/lib.rs b/crates/acp-tunnel/src/lib.rs
index c315fb4..52e89ba 100644
--- a/crates/acp-tunnel/src/lib.rs
+++ b/crates/acp-tunnel/src/lib.rs
@@ -24,6 +24,8 @@
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
 
+pub mod config;
+
 /// The ACP sub-protocol token the server echoes back on the `/acp` upgrade.
 pub const ACP_SUBPROTOCOL: &str = "acp.v1";
 
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index 1ae1d7f..ea4ea35 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -26,7 +26,16 @@ tauri-plugin-log = "2"
 # studio-cp / aws-config. Shell plugin bundles + spawns the sidecar; tokio sync
 # primitives multiplex JSON-RPC requests over its stdio.
 tauri-plugin-shell = "2"
-tokio = { version = "1", features = ["sync", "rt", "macros"] }
+tokio = { version = "1", features = ["sync", "rt", "macros", "net", "time"] }
+
+# Reverse-MCP-over-ACP (reverse-MCP client ADR, Part B): the pure protocol +
+# session state machine + remote-connection config live in `acp-tunnel`; the WS
+# transport here dials `/acp` and relays tunnelled MCP to the sidecar `McpClient`.
+acp-tunnel = { path = "../crates/acp-tunnel" }
+tokio-tungstenite = { version = "0.23", features = ["rustls-tls-webpki-roots"] }
+futures-util = "0.3"
+uuid = { version = "1", features = ["v4"] }
+dirs = "5"
 
 # Remote upgrade (ADR: remote-upgrade): the installed app pulls a signed nightly
 # bundle from the GitHub release and replaces itself in place. Driven from Rust
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 6d8c955..85ef090 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -1,4 +1,5 @@
 mod mcp;
+mod remote;
 
 use mcp::McpClient;
 use serde_json::{json, Value};
@@ -203,6 +204,74 @@ async fn deploy_scale(
     }
 }
 
+// ---- Remote reverse-MCP connection (reverse-MCP client ADR, Part B) ---------
+
+/// The remote-connection view the panel renders: the config file path + raw text
+/// (for the editor), the parsed URL, whether it is configured, and the live
+/// connection status. Parse is best-effort so a malformed file still opens in the
+/// editor (shown as not-configured) rather than blanking the panel.
+async fn remote_view(remote: &remote::Remote) -> Result<Value, String> {
+    let text = remote::read_config_text()?;
+    let cfg = acp_tunnel::config::RemoteConfig::parse(&text).unwrap_or_default();
+    let path = remote::config_path()
+        .map(|p| p.display().to_string())
+        .unwrap_or_default();
+    let status = remote.0.lock().await.status.clone();
+    Ok(json!({
+        "path": path,
+        "text": text,
+        "url": cfg.url,
+        "configured": cfg.is_configured(),
+        "status": if status.is_empty() { "disconnected".to_string() } else { status },
+    }))
+}
+
+/// The remote-connection config + status (the "declare" side of the remote panel).
+#[tauri::command]
+async fn remote_config(remote: tauri::State<'_, remote::Remote>) -> Result<Value, String> {
+    remote_view(&remote).await
+}
+
+/// Persist the edited `remote.toml` (validates it parses before writing) and
+/// return the refreshed view.
+#[tauri::command]
+async fn remote_config_write(
+    remote: tauri::State<'_, remote::Remote>,
+    text: String,
+) -> Result<Value, String> {
+    remote::write_config_text(&text)?;
+    remote_view(&remote).await
+}
+
+/// Activate the remote connection (the explicit "Activate" button): dial `/acp`
+/// using the saved config and publish the `oab` tools to the attached agent. The
+/// core sidecar must be started first (it is what the tunnel relays to).
+#[tauri::command]
+async fn remote_connect(
+    app: tauri::AppHandle,
+    core: tauri::State<'_, Core>,
+    remote: tauri::State<'_, remote::Remote>,
+) -> Result<(), String> {
+    let client = {
+        let guard = core.0.lock().await;
+        guard
+            .as_ref()
+            .cloned()
+            .ok_or_else(|| "core not started yet — start the core before connecting".to_string())?
+    };
+    remote::connect(app, &remote, client).await
+}
+
+/// Deactivate the remote connection.
+#[tauri::command]
+async fn remote_disconnect(
+    app: tauri::AppHandle,
+    remote: tauri::State<'_, remote::Remote>,
+) -> Result<(), String> {
+    remote::disconnect(&app, &remote).await;
+    Ok(())
+}
+
 /// What the frontend needs to render the "update available" state: the version
 /// on the release vs. what's running, plus the release notes.
 #[derive(serde::Serialize)]
@@ -265,6 +334,7 @@ pub fn run() {
                 )?;
             }
             app.manage(Core::default());
+            app.manage(remote::Remote::default());
             Ok(())
         })
         .invoke_handler(tauri::generate_handler![
@@ -274,6 +344,10 @@ pub fn run() {
             fleet_config,
             fleet_config_write,
             deploy_scale,
+            remote_config,
+            remote_config_write,
+            remote_connect,
+            remote_disconnect,
             check_update,
             install_update
         ])
diff --git a/src-tauri/src/mcp.rs b/src-tauri/src/mcp.rs
index 6d8a77f..52dfeec 100644
--- a/src-tauri/src/mcp.rs
+++ b/src-tauri/src/mcp.rs
@@ -157,7 +157,10 @@ impl McpClient {
     }
 
     /// Send a request and await the correlated `result` (or a formatted error).
-    async fn request(&self, method: &str, params: Value) -> Result<Value, String> {
+    /// Public so the reverse-MCP tunnel can relay an inner `tools/list` /
+    /// `tools/call` to the sidecar and return its **raw** MCP result verbatim
+    /// (unlike `call_tool`, which decodes the payload for the desktop UI).
+    pub async fn request(&self, method: &str, params: Value) -> Result<Value, String> {
         let id = self.inner.next_id.fetch_add(1, Ordering::Relaxed);
         let (tx, rx) = oneshot::channel();
         self.inner.pending.lock().await.insert(id, tx);
diff --git a/src-tauri/src/remote.rs b/src-tauri/src/remote.rs
new file mode 100644
index 0000000..b520c0e
--- /dev/null
+++ b/src-tauri/src/remote.rs
@@ -0,0 +1,268 @@
+//! Remote reverse-MCP-over-ACP connection (reverse-MCP client ADR, Part B).
+//!
+//! Studio dials the `/acp` endpoint from [`RemoteConfig`], creates a session
+//! declaring its `oab` server, and then **relays** the gateway's tunnelled MCP
+//! (`initialize` / `tools/list` / `tools/call`) to the already-running `oab-mcp`
+//! **sidecar** (`McpClient`) — no in-process aws link (ADR §4.3). Connection is
+//! **operator-triggered** (the "Activate remote connection" button), not on boot.
+//!
+//! The exact ACP `initialize` / `session/new` params and the end-to-end behaviour
+//! are validated against the live gateway once the §5 endpoint exists; this
+//! module is structurally complete and compiles under `desktop.yml`.
+
+use std::path::PathBuf;
+
+use acp_tunnel as acp;
+use acp_tunnel::config::RemoteConfig;
+use acp_tunnel::{Inbound, Session};
+use futures_util::{Sink, SinkExt, StreamExt};
+use serde_json::{json, Value};
+use tauri::{AppHandle, Emitter, Runtime};
+use tokio::sync::Mutex as AsyncMutex;
+use tokio_tungstenite::tungstenite::client::IntoClientRequest;
+use tokio_tungstenite::tungstenite::http::HeaderValue;
+use tokio_tungstenite::tungstenite::Message as WsMessage;
+
+use crate::mcp::McpClient;
+
+/// Managed state: the running connection task (abort to disconnect) plus the last
+/// status string the UI renders.
+#[derive(Default)]
+pub struct Remote(pub AsyncMutex<RemoteState>);
+
+#[derive(Default)]
+pub struct RemoteState {
+    task: Option<tauri::async_runtime::JoinHandle<()>>,
+    /// `"disconnected"` | `"connecting"` | `"connected"` | `"error: …"`.
+    pub status: String,
+}
+
+/// `~/.config/oab-studio/remote.toml` — beside `fleets.toml`.
+pub fn config_path() -> Result<PathBuf, String> {
+    dirs::config_dir()
+        .map(|d| d.join("oab-studio").join("remote.toml"))
+        .ok_or_else(|| "no config directory resolved".to_string())
+}
+
+/// Raw file text for the editor; a missing file is empty ("not configured").
+pub fn read_config_text() -> Result<String, String> {
+    let p = config_path()?;
+    match std::fs::read_to_string(&p) {
+        Ok(s) => Ok(s),
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(String::new()),
+        Err(e) => Err(format!("read {}: {e}", p.display())),
+    }
+}
+
+/// Persist edited text, **validating it parses first** (a bad edit never lands),
+/// mirroring the fleets.toml editor.
+pub fn write_config_text(text: &str) -> Result<(), String> {
+    RemoteConfig::parse(text).map_err(|e| format!("invalid TOML: {e}"))?;
+    let p = config_path()?;
+    if let Some(dir) = p.parent() {
+        std::fs::create_dir_all(dir).map_err(|e| format!("create {}: {e}", dir.display()))?;
+    }
+    std::fs::write(&p, text).map_err(|e| format!("write {}: {e}", p.display()))
+}
+
+fn load_config() -> Result<RemoteConfig, String> {
+    RemoteConfig::parse(&read_config_text()?).map_err(|e| format!("invalid remote.toml: {e}"))
+}
+
+fn emit_status<R: Runtime>(app: &AppHandle<R>, status: &str) {
+    let _ = app.emit("remote-status", json!({ "status": status }));
+}
+
+/// Activate the remote connection: validate config, spawn the connection task.
+/// Idempotent — a no-op if already connected.
+pub async fn connect<R: Runtime>(
+    app: AppHandle<R>,
+    remote: &Remote,
+    client: McpClient,
+) -> Result<(), String> {
+    let cfg = load_config()?;
+    cfg.validate()?;
+
+    let mut guard = remote.0.lock().await;
+    if guard.task.is_some() {
+        return Ok(());
+    }
+    let app_task = app.clone();
+    let task = tauri::async_runtime::spawn(async move {
+        run_reconnecting(app_task, cfg, client).await;
+    });
+    guard.task = Some(task);
+    guard.status = "connecting".to_string();
+    emit_status(&app, "connecting");
+    Ok(())
+}
+
+/// Deactivate: abort the connection task.
+pub async fn disconnect<R: Runtime>(app: &AppHandle<R>, remote: &Remote) {
+    let mut guard = remote.0.lock().await;
+    if let Some(t) = guard.task.take() {
+        t.abort();
+    }
+    guard.status = "disconnected".to_string();
+    emit_status(app, "disconnected");
+}
+
+/// Reconnect loop: one attempt, then back off and retry until the task is
+/// aborted (by [`disconnect`]).
+async fn run_reconnecting<R: Runtime>(app: AppHandle<R>, cfg: RemoteConfig, client: McpClient) {
+    loop {
+        if let Err(e) = run_once(&app, &cfg, &client).await {
+            emit_status(&app, &format!("error: {e}"));
+            let _ = app.emit(
+                "app-log",
+                json!({ "level": "error", "msg": format!("remote: {e}") }),
+            );
+        }
+        emit_status(&app, "connecting");
+        tokio::time::sleep(std::time::Duration::from_secs(5)).await;
+    }
+}
+
+/// One connection: dial, run the `initialize` → `session/new` handshake, then
+/// serve the gateway-initiated tunnel until the socket closes.
+async fn run_once<R: Runtime>(
+    app: &AppHandle<R>,
+    cfg: &RemoteConfig,
+    client: &McpClient,
+) -> Result<(), String> {
+    let mut req = cfg
+        .url
+        .as_str()
+        .into_client_request()
+        .map_err(|e| format!("bad url: {e}"))?;
+    // Bearer rides the WS sub-protocol offer (contract §1). Never logged.
+    let proto = HeaderValue::from_str(&acp::bearer_subprotocol(&cfg.token))
+        .map_err(|_| "invalid token in sub-protocol header".to_string())?;
+    req.headers_mut().insert("Sec-WebSocket-Protocol", proto);
+
+    let (ws, _resp) = tokio_tungstenite::connect_async(req)
+        .await
+        .map_err(|e| format!("dial {}: {e}", cfg.url))?;
+    let (mut write, mut read) = ws.split();
+
+    // Per-connection server id (contract §6.1); the stable name is "oab" (D1).
+    let conn_id = uuid::Uuid::new_v4().to_string();
+    let mut session = Session::new(vec![acp::oab_server(&conn_id)]);
+
+    // Drive the client handshake: initialize, then session/new declaring "oab".
+    let (_id, init) = session.initialize(json!({
+        "protocolVersion": "2024-11-05",
+        "clientCapabilities": {},
+        "clientInfo": { "name": "oab-studio", "version": env!("CARGO_PKG_VERSION") }
+    }));
+    send(&mut write, &init).await?;
+
+    // Read loop. Handshake responses (to our initialize / session/new) advance
+    // the session; gateway-initiated method frames are the tunnel.
+    while let Some(msg) = read.next().await {
+        let msg = msg.map_err(|e| format!("ws read: {e}"))?;
+        let text = match msg {
+            WsMessage::Text(t) => t,
+            WsMessage::Binary(b) => String::from_utf8_lossy(&b).into_owned(),
+            WsMessage::Close(_) => return Ok(()),
+            WsMessage::Ping(_) | WsMessage::Pong(_) | WsMessage::Frame(_) => continue,
+        };
+        if text.len() > acp::limits::MAX_FRAME_BYTES {
+            return Err("inbound frame exceeds 8 MiB".to_string());
+        }
+        let frame: Value = match serde_json::from_str(&text) {
+            Ok(v) => v,
+            Err(_) => continue, // ignore non-JSON keepalives
+        };
+
+        // A response (no `method`) is the ack to one of our handshake requests.
+        if frame.get("method").is_none() {
+            if session.phase() == acp::Phase::Initializing {
+                session.on_initialized();
+                let (_id, new) = session.open_session(&cfg.cwd);
+                send(&mut write, &new).await?;
+            } else if session.phase() == acp::Phase::Initialized {
+                let sid = frame
+                    .get("result")
+                    .and_then(|r| r.get("sessionId"))
+                    .and_then(Value::as_str)
+                    .unwrap_or_default()
+                    .to_string();
+                session.on_session_created(sid);
+                emit_status(app, "connected");
+                let _ = app.emit(
+                    "app-log",
+                    json!({ "level": "info", "msg": "remote: session active — oab tools published" }),
+                );
+            }
+            continue;
+        }
+
+        // Otherwise it is a gateway-initiated tunnel frame.
+        match acp::parse_inbound(&frame) {
+            Inbound::Connect { id, .. } => {
+                send(&mut write, &acp::connect_reply(id, &conn_id)).await?;
+            }
+            Inbound::Message {
+                id,
+                method,
+                params,
+                ..
+            } => {
+                if let Some(reply) = handle_inner(client, id, &method, params).await {
+                    send(&mut write, &reply).await?;
+                }
+            }
+            Inbound::Disconnect { id, .. } => {
+                send(&mut write, &acp::disconnect_reply(id)).await?;
+            }
+            // Cancellation is best-effort; relays are short and not tracked here.
+            Inbound::Cancel { .. } | Inbound::Other => {}
+        }
+    }
+    Ok(())
+}
+
+/// Answer one inner MCP method. `initialize` is answered locally (the sidecar is
+/// already initialized); `tools/list` / `tools/call` are relayed to the sidecar
+/// and returned **verbatim**. Returns `None` for a notification (no reply owed).
+async fn handle_inner(
+    client: &McpClient,
+    id: Option<Value>,
+    method: &str,
+    params: Value,
+) -> Option<Value> {
+    match method {
+        "notifications/initialized" => None,
+        "initialize" => id.map(|i| {
+            acp::message_reply(
+                i,
+                json!({
+                    "protocolVersion": "2024-11-05",
+                    "capabilities": { "tools": {} },
+                    "serverInfo": { "name": "oab-studio", "version": env!("CARGO_PKG_VERSION") }
+                }),
+            )
+        }),
+        "tools/list" | "tools/call" => {
+            let id = id?;
+            Some(match client.request(method, params).await {
+                Ok(result) => acp::message_reply(id, result),
+                Err(e) => acp::message_error(id, -32000, &e),
+            })
+        }
+        _ => id.map(|i| acp::message_error(i, -32601, &format!("method not found: {method}"))),
+    }
+}
+
+async fn send<S>(write: &mut S, frame: &Value) -> Result<(), String>
+where
+    S: Sink<WsMessage> + Unpin,
+    S::Error: std::fmt::Display,
+{
+    let text = serde_json::to_string(frame).map_err(|e| format!("encode: {e}"))?;
+    write
+        .send(WsMessage::Text(text))
+        .await
+        .map_err(|e| format!("ws write: {e}"))
+}