@@ -81,6 +81,10 @@ vi.mock("../../environments/primary", () => ({
   usePrimarySessionState: () => ({ data: null, error: null, isPending: false, refresh: vi.fn() }),
 }));
 
+vi.mock("../../state/session", () => ({
+  useEnvironmentSessionState: () => ({ data: null, hasError: false, isPending: true }),
+}));
+
 import { EnvironmentProviderSettings } from "./ProviderSettingsPanel";
 
 const environmentId = EnvironmentId.make("remote-device");
@@ -112,11 +116,14 @@ function provider(): ServerProvider {
   };
 }
 
-function renderPanel(): ReactElement<Record<string, unknown>> {
+function renderPanel(options?: {
+  readonly readOnly?: boolean;
+}): ReactElement<Record<string, unknown>> {
   hooks.beginRender();
   return EnvironmentProviderSettings({
     environmentId,
     environmentLabel: "Remote device",
+    ...(options?.readOnly === undefined ? {} : { readOnly: options.readOnly }),
   }) as ReactElement<Record<string, unknown>>;
 }
 
@@ -171,6 +178,35 @@ describe("EnvironmentProviderSettings routing", () => {
     });
   });
 
+  it("renders the provider layout inert with a limited-permissions notice when read only", () => {
+    atoms.providers = [provider()];
+    const panel = renderPanel({ readOnly: true });
+
+    const inertWrapper = visitElements(panel, (element) => element.props.inert === true);
+    expect(inertWrapper).not.toBeNull();
+    const providerCard = visitElements(panel, (element) => element.props.instanceId === codexId);
+    expect(providerCard).not.toBeNull();
+
+    const notice = visitElements(panel, (element) => element.props.title === "Limited permissions");
+    expect(notice).not.toBeNull();
+
+    expect(
+      visitElements(panel, (element) => element.props["aria-label"] === "Add provider instance"),
+    ).toBeNull();
+    expect(
+      visitElements(panel, (element) => element.props["aria-label"] === "Refresh provider status"),
+    ).toBeNull();
+  });
+
+  it("keeps the editable layout interactive when not read only", () => {
+    atoms.providers = [provider()];
+    const panel = renderPanel();
+    expect(visitElements(panel, (element) => element.props.inert === true)).toBeNull();
+    expect(
+      visitElements(panel, (element) => element.props.title === "Limited permissions"),
+    ).toBeNull();
+  });
+
   it("deletes and resets provider configuration without erasing shared preferences", () => {
     settingsState.value = {
       ...DEFAULT_UNIFIED_SETTINGS,
 
@@ -5,6 +5,7 @@ import {
   buildProviderEnvironmentOptions,
   classifyProviderEnvironmentAccess,
   resolvePrimaryOperateAccess,
+  resolveRemoteOperateAccess,
   resolveSelectedProviderEnvironmentId,
 } from "./ProviderSettingsPanel.logic";
 
@@ -203,3 +204,57 @@ describe("primary operate access", () => {
     ).toBe("granted");
   });
 });
+
+describe("remote operate access", () => {
+  it("derives access from the environment session's granted scopes", () => {
+    expect(
+      resolveRemoteOperateAccess({
+        session: { authenticated: true, scopes: [AuthOrchestrationOperateScope] },
+        isPending: false,
+        hasError: false,
+      }),
+    ).toBe("granted");
+    expect(
+      resolveRemoteOperateAccess({
+        session: { authenticated: true, scopes: ["orchestration:read"] },
+        isPending: false,
+        hasError: false,
+      }),
+    ).toBe("denied");
+    expect(
+      resolveRemoteOperateAccess({
+        session: { authenticated: false },
+        isPending: false,
+        hasError: false,
+      }),
+    ).toBe("denied");
+  });
+
+  it("reports pending before the first session resolve, then keeps cached data", () => {
+    expect(resolveRemoteOperateAccess({ session: null, isPending: true, hasError: false })).toBe(
+      "pending",
+    );
+    expect(
+      resolveRemoteOperateAccess({
+        session: { authenticated: true, scopes: [AuthOrchestrationOperateScope] },
+        isPending: true,
+        hasError: false,
+      }),
+    ).toBe("granted");
+  });
+
+  it("stays optimistic when the session fetch fails or an older server omits scopes", () => {
+    // Transport failures and pre-scope-reporting servers are not permission
+    // decisions; the environment RPC layer still rejects unauthorized writes.
+    expect(resolveRemoteOperateAccess({ session: null, isPending: false, hasError: true })).toBe(
+      "granted",
+    );
+    expect(
+      resolveRemoteOperateAccess({
+        session: { authenticated: true },
+        isPending: false,
+        hasError: false,
+      }),
+    ).toBe("granted");
+  });
+});
@@ -64,28 +64,26 @@ export type ProviderEnvironmentAccess =
 export type ProviderOperateAccess = "granted" | "denied" | "pending";
 
 /**
- * Resolve whether the session may reconfigure providers on an environment.
+ * Resolve operate access from an environment's `/api/auth/session` answer.
  *
- * Only the primary environment exposes its own granted scopes to the client
- * today, so remote sessions are optimistic: the connection brokers request
- * `orchestration:operate`, and the environment RPC layer stays authoritative if
- * a narrower credential was minted.
+ * Cached session data wins over an in-flight revalidation. The session atoms
+ * are SWR-backed, so they report `isPending` on every background refresh;
+ * treating that as unknown would flip a working panel back to loading and
+ * discard in-progress edits.
  *
- * Cached session data wins over an in-flight revalidation. The session atom is
- * SWR-backed, so it reports `isPending` on every background refresh; treating
- * that as unknown would flip a working panel back to loading and discard
- * in-progress edits.
+ * `missingScopesAccess` decides the case where the session resolved but did
+ * not report scopes: the primary serves the web app itself so its server
+ * always reports them (absence means denial), while a remote device may run an
+ * older server version that predates scope reporting, where denial would lock
+ * out a legitimate session. The environment RPC layer stays authoritative
+ * either way.
  */
-export function resolvePrimaryOperateAccess(input: {
-  readonly isPrimary: boolean;
-  readonly hasDesktopBridge: boolean;
+function resolveSessionOperateAccess(input: {
   readonly session: Pick<AuthSessionState, "authenticated" | "scopes"> | null;
   readonly isPending: boolean;
   readonly hasError: boolean;
+  readonly missingScopesAccess: "granted" | "denied";
 }): ProviderOperateAccess {
-  if (!input.isPrimary || input.hasDesktopBridge) {
-    return "granted";
-  }
   if (input.session === null) {
     if (input.isPending) {
       return "pending";
@@ -98,9 +96,44 @@ export function resolvePrimaryOperateAccess(input: {
   if (!input.session.authenticated) {
     return "denied";
   }
-  return (input.session.scopes ?? []).includes(AuthOrchestrationOperateScope)
-    ? "granted"
-    : "denied";
+  if (input.session.scopes === undefined) {
+    return input.missingScopesAccess;
+  }
+  return input.session.scopes.includes(AuthOrchestrationOperateScope) ? "granted" : "denied";
+}
+
+/** Operate access for the primary environment's own browser session. */
+export function resolvePrimaryOperateAccess(input: {
+  readonly isPrimary: boolean;
+  readonly hasDesktopBridge: boolean;
+  readonly session: Pick<AuthSessionState, "authenticated" | "scopes"> | null;
+  readonly isPending: boolean;
+  readonly hasError: boolean;
+}): ProviderOperateAccess {
+  if (!input.isPrimary || input.hasDesktopBridge) {
+    return "granted";
+  }
+  return resolveSessionOperateAccess({
+    session: input.session,
+    isPending: input.isPending,
+    hasError: input.hasError,
+    missingScopesAccess: "denied",
+  });
+}
+
+/**
+ * Operate access for a non-primary environment, derived from the scopes its
+ * `/api/auth/session` endpoint reports for this client's credential.
+ */
+export function resolveRemoteOperateAccess(input: {
+  readonly session: Pick<AuthSessionState, "authenticated" | "scopes"> | null;
+  readonly isPending: boolean;
+  readonly hasError: boolean;
+}): ProviderOperateAccess {
+  return resolveSessionOperateAccess({
+    ...input,
+    missingScopesAccess: "granted",
+  });
 }
 
 export function classifyProviderEnvironmentAccess(input: {