diff --git a/backend/src/db/migrations/202610181200-opencode-servers.ts b/backend/src/db/migrations/202610181200-opencode-servers.ts
new file mode 100644
index 000000000..6fab50dd5
--- /dev/null
+++ b/backend/src/db/migrations/202610181200-opencode-servers.ts
@@ -0,0 +1,26 @@
+import type { Migration } from '../migration-runner'
+
+const migration: Migration = {
+  id: '202610181200-opencode-servers',
+
+  up(db) {
+    db.run(`
+      CREATE TABLE IF NOT EXISTS opencode_servers (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        base_url TEXT NOT NULL,
+        username TEXT NOT NULL,
+        enabled INTEGER NOT NULL DEFAULT 1,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      )
+    `)
+  },
+
+  down(db) {
+    db.run('DROP TABLE IF EXISTS opencode_servers')
+    db.run("DELETE FROM app_secrets WHERE key LIKE 'opencode_server:%:password'")
+  },
+}
+
+export default migration
diff --git a/backend/src/db/migrations/index.ts b/backend/src/db/migrations/index.ts
index b04854719..93cb73794 100644
--- a/backend/src/db/migrations/index.ts
+++ b/backend/src/db/migrations/index.ts
@@ -33,6 +33,7 @@ import migration202610081200 from './202610081200-change-walkthrough-sources'
 import migration202610141200 from './202610141200-session-sandbox-modes'
 import migration202610151200 from './202610151200-change-walkthrough-sessions'
 import migration202610161200 from './202610161200-change-walkthrough-execution'
+import migration202610181200 from './202610181200-opencode-servers'
 
 export const allMigrations: Migration[] = [
   migration001,
@@ -69,4 +70,5 @@ export const allMigrations: Migration[] = [
   migration202610141200,
   migration202610151200,
   migration202610161200,
+  migration202610181200,
 ]
diff --git a/backend/src/db/opencode-servers.ts b/backend/src/db/opencode-servers.ts
new file mode 100644
index 000000000..7d981017c
--- /dev/null
+++ b/backend/src/db/opencode-servers.ts
@@ -0,0 +1,161 @@
+import { randomBytes } from 'node:crypto'
+import type { Database } from 'bun:sqlite'
+import type { OpenCodeServer } from '@opencode-manager/shared/schemas'
+import { trimUrlTrailingSlashes } from '@opencode-manager/shared/utils'
+import { deleteSecret, readEncryptedSecret, writeEncryptedSecret } from './secrets'
+
+interface OpenCodeServerRow {
+  id: string
+  name: string
+  base_url: string
+  username: string
+  enabled: number
+  created_at: number
+  updated_at: number
+  has_password: number
+}
+
+export interface OpenCodeServerInsert {
+  name: string
+  baseUrl: string
+  username: string
+  enabled: boolean
+  password?: string | null
+}
+
+export interface OpenCodeServerUpdate {
+  name?: string
+  baseUrl?: string
+  username?: string
+  enabled?: boolean
+  password?: string | null
+}
+
+const ROW_COLUMNS = 'id, name, base_url, username, enabled, created_at, updated_at'
+
+const PASSWORD_SECRET_KEY_PREFIX = 'opencode_server:'
+const PASSWORD_SECRET_KEY_SUFFIX = ':password'
+
+const SELECT_SERVER = `
+  SELECT s.id, s.name, s.base_url, s.username, s.enabled, s.created_at, s.updated_at,
+         CASE WHEN k.key IS NULL THEN 0 ELSE 1 END AS has_password
+  FROM opencode_servers s
+  LEFT JOIN app_secrets k ON k.key = '${PASSWORD_SECRET_KEY_PREFIX}' || s.id || '${PASSWORD_SECRET_KEY_SUFFIX}'
+`
+
+function passwordSecretKey(serverId: string): string {
+  return `${PASSWORD_SECRET_KEY_PREFIX}${serverId}${PASSWORD_SECRET_KEY_SUFFIX}`
+}
+
+function mapRow(row: OpenCodeServerRow): OpenCodeServer {
+  return {
+    id: row.id,
+    name: row.name,
+    baseUrl: row.base_url,
+    username: row.username,
+    enabled: row.enabled === 1,
+    hasPassword: row.has_password === 1,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  }
+}
+
+export function listOpenCodeServers(db: Database): OpenCodeServer[] {
+  const rows = db
+    .prepare(`${SELECT_SERVER} ORDER BY s.name COLLATE NOCASE, s.created_at`)
+    .all() as OpenCodeServerRow[]
+  return rows.map(mapRow)
+}
+
+export function getOpenCodeServer(db: Database, serverId: string): OpenCodeServer | null {
+  const row = db
+    .prepare(`${SELECT_SERVER} WHERE s.id = ?`)
+    .get(serverId) as OpenCodeServerRow | undefined
+  return row ? mapRow(row) : null
+}
+
+export function readOpenCodeServerPassword(db: Database, serverId: string): string | null {
+  return readEncryptedSecret(db, passwordSecretKey(serverId))
+}
+
+export function insertOpenCodeServer(db: Database, input: OpenCodeServerInsert): OpenCodeServer {
+  const id = `srv_${randomBytes(18).toString('base64url')}`
+  const now = Date.now()
+
+  const insert = db.transaction(() => {
+    db.prepare(`INSERT INTO opencode_servers (${ROW_COLUMNS}) VALUES (?, ?, ?, ?, ?, ?, ?)`).run(
+      id,
+      input.name,
+      trimUrlTrailingSlashes(input.baseUrl),
+      input.username,
+      input.enabled ? 1 : 0,
+      now,
+      now,
+    )
+    if (input.password) {
+      writeEncryptedSecret(db, passwordSecretKey(id), input.password)
+    }
+    return getOpenCodeServer(db, id)
+  })
+
+  const server = insert()
+  if (!server) {
+    throw new Error(`Failed to read the OpenCode server inserted with id ${id}`)
+  }
+  return server
+}
+
+export function updateOpenCodeServer(
+  db: Database,
+  serverId: string,
+  patch: OpenCodeServerUpdate,
+): OpenCodeServer | null {
+  const update = db.transaction(() => {
+    if (!getOpenCodeServer(db, serverId)) return null
+
+    const assignments: string[] = []
+    const values: Array<string | number> = []
+
+    if (patch.name !== undefined) {
+      assignments.push('name = ?')
+      values.push(patch.name)
+    }
+    if (patch.baseUrl !== undefined) {
+      assignments.push('base_url = ?')
+      values.push(trimUrlTrailingSlashes(patch.baseUrl))
+    }
+    if (patch.username !== undefined) {
+      assignments.push('username = ?')
+      values.push(patch.username)
+    }
+    if (patch.enabled !== undefined) {
+      assignments.push('enabled = ?')
+      values.push(patch.enabled ? 1 : 0)
+    }
+
+    assignments.push('updated_at = ?')
+    values.push(Date.now())
+
+    db.prepare(`UPDATE opencode_servers SET ${assignments.join(', ')} WHERE id = ?`).run(...values, serverId)
+
+    if (patch.password === null) {
+      deleteSecret(db, passwordSecretKey(serverId))
+    } else if (patch.password !== undefined) {
+      writeEncryptedSecret(db, passwordSecretKey(serverId), patch.password)
+    }
+
+    return getOpenCodeServer(db, serverId)
+  })
+
+  return update()
+}
+
+export function deleteOpenCodeServer(db: Database, serverId: string): boolean {
+  const remove = db.transaction(() => {
+    const result = db.prepare('DELETE FROM opencode_servers WHERE id = ?').run(serverId)
+    deleteSecret(db, passwordSecretKey(serverId))
+    return result.changes > 0
+  })
+
+  return remove()
+}
diff --git a/backend/src/db/secrets.ts b/backend/src/db/secrets.ts
new file mode 100644
index 000000000..50c539389
--- /dev/null
+++ b/backend/src/db/secrets.ts
@@ -0,0 +1,27 @@
+import type { Database } from 'bun:sqlite'
+import { decryptSecret, encryptSecret } from '../utils/crypto'
+import { logger } from '../utils/logger'
+
+export function readEncryptedSecret(db: Database, key: string): string | null {
+  const row = db.prepare('SELECT value FROM app_secrets WHERE key = ?').get(key) as { value: string } | undefined
+  if (!row) return null
+
+  try {
+    return decryptSecret(row.value)
+  } catch (error) {
+    logger.error(`Failed to decrypt ${key}`, error)
+    return null
+  }
+}
+
+export function writeEncryptedSecret(db: Database, key: string, value: string): void {
+  const now = Date.now()
+  db.prepare(`
+    INSERT INTO app_secrets (key, value, created_at, updated_at) VALUES (?, ?, ?, ?)
+    ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
+  `).run(key, encryptSecret(value), now, now)
+}
+
+export function deleteSecret(db: Database, key: string): void {
+  db.prepare('DELETE FROM app_secrets WHERE key = ?').run(key)
+}
diff --git a/backend/src/index.ts b/backend/src/index.ts
index c08933600..73ae3d4cb 100644
--- a/backend/src/index.ts
+++ b/backend/src/index.ts
@@ -51,7 +51,10 @@ import { createInternalRoutes } from './routes/internal'
 import { sweepStaleUploadSessions } from './routes/internal/repo-mirror-helpers'
 import { createOpenCodeProxyRoutes } from './routes/opencode-proxy'
 import { createAuthenticatedOpenCodeProxyRoutes } from './routes/opencode-auth-proxy'
+import { createOpenCodeServerProxyRoutes } from './routes/opencode-server-proxy'
+import { createOpenCodeServerRoutes } from './routes/opencode-servers'
 import { sseAggregator } from './services/sse-aggregator'
+import { RemoteServerEventHub } from './services/remote-server-events'
 import { ensureDirectoryExists, writeFileContent, fileExists } from './services/file-operations'
 import { SettingsService } from './services/settings'
 import { SessionPermissionModeService } from './services/session-permission-modes'
@@ -62,6 +65,7 @@ import { MultiRunService } from './services/multi-runs'
 import { ChangeWalkthroughService } from './services/change-walkthroughs'
 import { opencodeServerManager } from './services/opencode-single-server'
 import { createOpenCodeClient } from './services/opencode/client'
+import { OpenCodeServerRegistry } from './services/opencode-server-registry'
 import { getOpenCodeUpstreamBaseUrl } from './services/opencode/upstream'
 import { NotificationService } from './services/notification'
 import { ScheduleRunner, ScheduleService } from './services/schedules'
@@ -127,6 +131,7 @@ const openCodeClient = createOpenCodeClient(
   () => new SettingsService(db).getOpenCodeServerPassword(),
   () => opencodeServerManager.getEffectiveServerHost(),
 )
+export const opencodeServerRegistry = new OpenCodeServerRegistry(db, openCodeClient)
 
 import { DEFAULT_AGENTS_MD } from './constants'
 
@@ -340,6 +345,9 @@ sseAggregator.onUpstreamConnected(() => {
 })
 sseAggregator.start()
 
+const remoteServerEvents = new RemoteServerEventHub(opencodeServerRegistry, sseAggregator)
+remoteServerEvents.start()
+
 void sessionGoalService.recoverOpenGoals().catch((error) => {
   logger.error('Session goal recovery error:', error)
 })
@@ -379,6 +387,7 @@ protectedApi.route('/ssh', createSSHRoutes(gitAuthService))
 protectedApi.route('/notifications', createNotificationRoutes(notificationService))
 protectedApi.route('/prompt-templates', createPromptTemplateRoutes(db))
 protectedApi.route('/session-pins', createSessionPinRoutes(db))
+protectedApi.route('/opencode-servers', createOpenCodeServerRoutes(opencodeServerRegistry, () => remoteServerEvents.getStatuses()))
 protectedApi.route('/session-permission-modes', createSessionPermissionModeRoutes(sessionPermissionModeService))
 protectedApi.route('/session-sandbox', createSessionSandboxRoutes(sessionSandboxService))
 protectedApi.route('/session-goals', createSessionGoalRoutes(sessionGoalService))
@@ -390,6 +399,7 @@ protectedApi.route('/preview', createPreviewRoutes({ store: previewSessionStore,
 
 app.route('/api', protectedApi)
 
+app.route('/api/opencode/servers', createOpenCodeServerProxyRoutes(opencodeServerRegistry, requireAuth))
 app.route('/api/opencode', createAuthenticatedOpenCodeProxyRoutes(openCodeClient, requireAuth))
 
 const isProduction = ENV.SERVER.NODE_ENV === 'production'
@@ -468,6 +478,8 @@ const shutdown = async (signal: string) => {
 
   logger.info(`${signal} received, shutting down gracefully...`)
   try {
+    remoteServerEvents.shutdown()
+    logger.info('Remote server event hub stopped')
     sseAggregator.shutdown()
     logger.info('SSE Aggregator stopped')
     if (ipcServer) {
diff --git a/backend/src/routes/opencode-server-proxy.ts b/backend/src/routes/opencode-server-proxy.ts
new file mode 100644
index 000000000..b86041b3d
--- /dev/null
+++ b/backend/src/routes/opencode-server-proxy.ts
@@ -0,0 +1,149 @@
+import { Hono } from 'hono'
+import type { ContentfulStatusCode } from 'hono/utils/http-status'
+import type { MiddlewareHandler } from 'hono'
+import {
+  OpenCodeServerError,
+  type OpenCodeServerConnection,
+  type OpenCodeServerRegistry,
+} from '../services/opencode-server-registry'
+import { filterProxyHeaders, NULL_BODY_STATUSES } from '../utils/proxy-headers'
+import { logger } from '../utils/logger'
+
+const MOUNT_PREFIX = '/api/opencode/servers/'
+const REQUEST_EXCLUDED_HEADERS = new Set(['cookie', 'origin', 'referer'])
+const RESPONSE_EXCLUDED_HEADERS = new Set(['set-cookie'])
+
+type UpstreamPath = { ok: true; path: string } | { ok: false; status: 400 | 404 }
+
+function decodeSegment(segment: string): string | null {
+  let decoded: string
+  try {
+    decoded = decodeURIComponent(segment)
+  } catch {
+    return null
+  }
+  try {
+    return decodeURIComponent(decoded)
+  } catch {
+    return decoded
+  }
+}
+
+function decodePathSegments(path: string): string[] | null {
+  const segments: string[] = []
+  for (const segment of path.split('/')) {
+    const decoded = decodeSegment(segment)
+    if (decoded === null) return null
+    if (decoded === '.' || decoded === '..' || decoded.includes('/') || decoded.includes('\\')) return null
+    segments.push(decoded)
+  }
+  return segments
+}
+
+/**
+ * Resolves the upstream path for a request mounted at `/api/opencode/servers`.
+ * Only OpenCode API paths are forwardable, and encoded traversal segments are refused.
+ */
+function resolveUpstreamPath(pathname: string): UpstreamPath {
+  const remainder = pathname.slice(MOUNT_PREFIX.length)
+  const separator = remainder.indexOf('/')
+  const encodedPath = separator === -1 ? '/' : remainder.slice(separator)
+  const segments = decodePathSegments(encodedPath)
+  if (!segments) return { ok: false, status: 400 }
+
+  const path = segments.join('/')
+  return path.startsWith('/api/') ? { ok: true, path } : { ok: false, status: 404 }
+}
+
+type UpstreamTarget = { basePath: string; url: URL }
+
+/**
+ * Builds the upstream URL for a resolved API path. The returned `basePath` is the
+ * connection base path without trailing slashes and is used to bound the final,
+ * URL-normalized pathname to the connection's own `/api/` space.
+ */
+function resolveUpstreamTarget(
+  connection: OpenCodeServerConnection,
+  path: string,
+  search: string,
+): UpstreamTarget {
+  const url = new URL(connection.baseUrl)
+  const basePath = url.pathname.replace(/\/+$/, '')
+  url.pathname = `${basePath}${path}`
+  url.search = search
+  return { basePath, url }
+}
+
+function isWithinUpstreamApiPath(basePath: string, pathname: string): boolean {
+  return pathname.startsWith(`${basePath}/api/`)
+}
+
+export function createOpenCodeServerProxyRoutes(
+  registry: OpenCodeServerRegistry,
+  requireAuth: MiddlewareHandler,
+  fetchFn: typeof fetch = fetch,
+): Hono {
+  const app = new Hono()
+
+  app.all('/:serverId/*', requireAuth, async (c) => {
+    const url = new URL(c.req.url)
+    const upstreamPath = resolveUpstreamPath(url.pathname)
+    if (!upstreamPath.ok) {
+      return upstreamPath.status === 400
+        ? c.json({ error: 'Invalid proxy path' }, 400)
+        : c.json({ error: 'Not found' }, 404)
+    }
+
+    let connection: OpenCodeServerConnection
+    try {
+      connection = registry.getConnection(c.req.param('serverId'))
+    } catch (error) {
+      if (error instanceof OpenCodeServerError) {
+        return c.json({ error: error.message }, error.status as ContentfulStatusCode)
+      }
+      logger.error('Failed to resolve OpenCode server connection', error)
+      return c.json({ error: 'Failed to proxy request' }, 500)
+    }
+
+    const upstream = resolveUpstreamTarget(connection, upstreamPath.path, url.search)
+    if (!isWithinUpstreamApiPath(upstream.basePath, upstream.url.pathname)) {
+      return c.json({ error: 'Invalid proxy path' }, 400)
+    }
+
+    const headers = filterProxyHeaders(c.req.raw.headers, REQUEST_EXCLUDED_HEADERS)
+    if (connection.authorization) {
+      headers.Authorization = connection.authorization
+    }
+
+    const hasBody = c.req.method !== 'GET' && c.req.method !== 'HEAD'
+
+    try {
+      const upstreamResponse = await fetchFn(upstream.url.toString(), {
+        method: c.req.method,
+        headers,
+        body: hasBody ? c.req.raw.body : undefined,
+        redirect: 'manual',
+        signal: c.req.raw.signal,
+        duplex: 'half',
+      })
+
+      const responseHeaders = new Headers(
+        filterProxyHeaders(upstreamResponse.headers, RESPONSE_EXCLUDED_HEADERS),
+      )
+      const responseBody = NULL_BODY_STATUSES.has(upstreamResponse.status)
+        ? null
+        : upstreamResponse.body
+
+      return new Response(responseBody, {
+        status: upstreamResponse.status,
+        statusText: upstreamResponse.statusText,
+        headers: responseHeaders,
+      })
+    } catch (error) {
+      logger.warn(`OpenCode server proxy request failed: ${c.req.method} ${upstream.url.host}${upstreamPath.path}`, error)
+      return c.json({ error: 'Remote OpenCode server unreachable' }, 502)
+    }
+  })
+
+  return app
+}
diff --git a/backend/src/routes/opencode-servers.ts b/backend/src/routes/opencode-servers.ts
new file mode 100644
index 000000000..b6f2fb6c8
--- /dev/null
+++ b/backend/src/routes/opencode-servers.ts
@@ -0,0 +1,99 @@
+import { Hono } from 'hono'
+import {
+  CreateOpenCodeServerRequestSchema,
+  TestOpenCodeServerRequestSchema,
+  UpdateOpenCodeServerRequestSchema,
+  type OpenCodeServerStatus,
+} from '@opencode-manager/shared/schemas'
+import { OpenCodeServerError, type OpenCodeServerRegistry } from '../services/opencode-server-registry'
+import { handleServiceError, parseJsonBody } from '../utils/route-helpers'
+
+export type OpenCodeServerStatusProvider = () => OpenCodeServerStatus[]
+
+export function createOpenCodeServerRoutes(
+  registry: OpenCodeServerRegistry,
+  statusProvider: OpenCodeServerStatusProvider,
+) {
+  const app = new Hono()
+
+  app.get('/', (c) => {
+    try {
+      return c.json({ servers: registry.list() })
+    } catch (error) {
+      return handleServiceError(c, error, 'Failed to list OpenCode servers', OpenCodeServerError)
+    }
+  })
+
+  app.post('/', async (c) => {
+    const parsed = await parseJsonBody(c, CreateOpenCodeServerRequestSchema)
+    if (!parsed.ok) return parsed.response
+
+    try {
+      const server = await registry.create(parsed.data)
+      const test = await registry.test({ serverId: server.id })
+      return c.json({ server, test }, 201)
+    } catch (error) {
+      return handleServiceError(c, error, 'Failed to create OpenCode server', OpenCodeServerError)
+    }
+  })
+
+  app.post('/test', async (c) => {
+    const parsed = await parseJsonBody(c, TestOpenCodeServerRequestSchema)
+    if (!parsed.ok) return parsed.response
+
+    try {
+      return c.json(await registry.test(parsed.data))
+    } catch (error) {
+      return handleServiceError(c, error, 'Failed to test OpenCode server', OpenCodeServerError)
+    }
+  })
+
+  app.get('/status', (c) => {
+    try {
+      return c.json({ statuses: statusProvider() })
+    } catch (error) {
+      return handleServiceError(c, error, 'Failed to read OpenCode server status', OpenCodeServerError)
+    }
+  })
+
+  app.get('/:id', (c) => {
+    try {
+      const server = registry.get(c.req.param('id'))
+      if (!server) return c.json({ error: 'OpenCode server not found' }, 404)
+      return c.json({ server })
+    } catch (error) {
+      return handleServiceError(c, error, 'Failed to read OpenCode server', OpenCodeServerError)
+    }
+  })
+
+  app.patch('/:id', async (c) => {
+    const parsed = await parseJsonBody(c, UpdateOpenCodeServerRequestSchema)
+    if (!parsed.ok) return parsed.response
+
+    try {
+      const server = await registry.update(c.req.param('id'), parsed.data)
+      return c.json({ server })
+    } catch (error) {
+      return handleServiceError(c, error, 'Failed to update OpenCode server', OpenCodeServerError)
+    }
+  })
+
+  app.delete('/:id', (c) => {
+    try {
+      registry.delete(c.req.param('id'))
+      return c.body(null, 204)
+    } catch (error) {
+      return handleServiceError(c, error, 'Failed to delete OpenCode server', OpenCodeServerError)
+    }
+  })
+
+  app.post('/:id/test', async (c) => {
+    try {
+      return c.json(await registry.test({ serverId: c.req.param('id') }))
+    } catch (error) {
+      return handleServiceError(c, error, 'Failed to test OpenCode server', OpenCodeServerError)
+    }
+  })
+
+  return app
+}
diff --git a/backend/src/services/opencode-event-routing.ts b/backend/src/services/opencode-event-routing.ts
new file mode 100644
index 000000000..877e2b949
--- /dev/null
+++ b/backend/src/services/opencode-event-routing.ts
@@ -0,0 +1,140 @@
+import { EventSource } from 'eventsource'
+import { openCodeLocation, sessionIDFromEvent, type OpenCodeApi, type V2Event } from '@opencode-manager/shared/opencode'
+import { logger } from '../utils/logger'
+
+const MULTILINE_PATTERN = /[\r\n]/
+
+export type ReplayEventType = 'permission.asked' | 'form.created' | 'session.status'
+
+export type ReplayEventBuilder = (type: ReplayEventType, directory: string, data: unknown) => V2Event
+
+export interface RoutedOpenCodeEvent {
+  event: V2Event
+  payloadJson: string
+  directory: string | undefined
+  resolvedDirectory: string | undefined
+}
+
+export interface PendingReplayRequest {
+  api: OpenCodeApi
+  directory: string
+  buildEvent: ReplayEventBuilder
+  logScope: string
+  logTarget: string
+}
+
+export interface PendingReplayEvents {
+  permissions: V2Event[]
+  forms: V2Event[]
+}
+
+export interface SessionStatusReplayPlan {
+  idle: Array<{ sessionID: string; directory: string }>
+  busy: string[]
+}
+
+export type EventSourceInit = ConstructorParameters<typeof EventSource>[1]
+
+/**
+ * Partitions tracked sessions into those that must be replayed as idle and the
+ * active sessions that must be replayed as busy.
+ */
+export function planSessionStatusReplay(
+  active: Record<string, unknown>,
+  tracked: ReadonlyMap<string, string>,
+): SessionStatusReplayPlan {
+  const busy = Object.keys(active ?? {})
+  const busySet = new Set(busy)
+  const idle: Array<{ sessionID: string; directory: string }> = []
+  for (const [sessionID, directory] of tracked) {
+    if (!busySet.has(sessionID)) idle.push({ sessionID, directory })
+  }
+  return { idle, busy }
+}
+
+export function createReplayEventBuilder(idPrefix: string): ReplayEventBuilder {
+  let count = 0
+  return (type, directory, data) => {
+    count += 1
+    return {
+      id: `${idPrefix}${count}`,
+      created: Date.now(),
+      type,
+      location: { directory },
+      data,
+    } as V2Event
+  }
+}
+
+export function parseOpenCodeEvent(data: string, sessionDirectories: Map<string, string>): RoutedOpenCodeEvent | null {
+  let event: V2Event
+  try {
+    event = JSON.parse(data) as V2Event
+  } catch {
+    return null
+  }
+
+  if (!event?.type) return null
+
+  const payloadJson = MULTILINE_PATTERN.test(data) ? JSON.stringify(event) : data
+  const directory = event.location?.directory
+  const sessionID = sessionIDFromEvent(event)
+  const forkParentId = event.type === 'session.forked' ? event.data.parentID : undefined
+  const inheritedDirectory = forkParentId ? sessionDirectories.get(forkParentId) : undefined
+  const rememberedDirectory = directory ?? inheritedDirectory
+  const resolvedDirectory = rememberedDirectory ?? (sessionID ? sessionDirectories.get(sessionID) : undefined)
+
+  if (sessionID && event.type === 'session.deleted') {
+    sessionDirectories.delete(sessionID)
+  } else if (sessionID && rememberedDirectory) {
+    sessionDirectories.set(sessionID, rememberedDirectory)
+  }
+
+  return { event, payloadJson, directory, resolvedDirectory }
+}
+
+export async function collectPendingReplayEvents(request: PendingReplayRequest): Promise<PendingReplayEvents> {
+  const { api, directory, buildEvent, logScope, logTarget } = request
+  const [permissionsResult, formsResult] = await Promise.allSettled([
+    api.permission.request.list(openCodeLocation(directory)),
+    api.form.list(openCodeLocation(directory)),
+  ])
+
+  const permissions: V2Event[] = []
+  if (permissionsResult.status === 'rejected') {
+    logger.warn(`${logScope}: failed to fetch pending permissions for ${logTarget}: ${String(permissionsResult.reason)}`)
+  } else {
+    for (const permission of permissionsResult.value.data) {
+      permissions.push(buildEvent('permission.asked', directory, permission))
+    }
+  }
+
+  const forms: V2Event[] = []
+  if (formsResult.status === 'rejected') {
+    logger.warn(`${logScope}: failed to fetch pending forms for ${logTarget}: ${String(formsResult.reason)}`)
+  } else {
+    for (const form of formsResult.value.data) {
+      forms.push(buildEvent('form.created', directory, { form }))
+    }
+  }
+
+  return { permissions, forms }
+}
+
+export function createAuthorizedEventSourceInit(authorization: string | null): EventSourceInit {
+  if (!authorization) return undefined
+  return {
+    fetch: (input, init) =>
+      fetch(input, {
+        ...init,
+        headers: {
+          ...(init?.headers ?? {}),
+          Authorization: authorization,
+        },
+      }),
+  }
+}
+
+export function nextBackoffDelay(currentDelayMs: number, maxDelayMs: number): number {
+  return Math.min(currentDelayMs * 2, maxDelayMs)
+}
diff --git a/backend/src/services/opencode-server-registry.test.ts b/backend/src/services/opencode-server-registry.test.ts
new file mode 100644
index 000000000..168dcb818
--- /dev/null
+++ b/backend/src/services/opencode-server-registry.test.ts
@@ -0,0 +1,604 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { Database } from 'bun:sqlite'
+import type { OpenCodeServer } from '@opencode-manager/shared/schemas'
+import { encryptOpenCodePairingCredentials, verifyOpenCodePairingProof } from '@opencode-manager/shared/opencode'
+import { migrate } from '../db/migration-runner'
+import { allMigrations } from '../db/migrations'
+import { decryptSecret } from '../utils/crypto'
+import {
+  OpenCodeServerCredentialsRequiredError,
+  OpenCodeServerError,
+  OpenCodeServerNotFoundError,
+  OpenCodeServerPairingError,
+  OpenCodeServerRegistry,
+  type OpenCodeServerChange,
+} from './opencode-server-registry'
+import { FetchOpenCodeClient, type OpenCodeClient } from './opencode/client'
+
+vi.mock('../utils/logger', () => ({
+  logger: {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  },
+}))
+
+type FetchMock = ReturnType<typeof vi.fn<(input: string | URL | Request, init?: RequestInit) => Promise<Response>>>
+
+const PAIR_URL = 'https://remote.example.com/pair'
+const PAIR_CODE = '0123456789abcdef'
+
+function createTestDb(): Database {
+  const db = new Database(':memory:')
+  migrate(db, allMigrations)
+  return db
+}
+
+function createLocalClient(): OpenCodeClient {
+  return { api: {} as OpenCodeClient['api'], forwardRaw: vi.fn() }
+}
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), { status, headers: { 'Content-Type': 'application/json' } })
+}
+
+function readStoredSecret(db: Database, serverId: string): { value: string } | undefined {
+  return db
+    .prepare('SELECT value FROM app_secrets WHERE key = ?')
+    .get(`opencode_server:${serverId}:password`) as { value: string } | undefined
+}
+
+function flipLastByte(value: string): string {
+  const bytes = Buffer.from(value.replace(/-/g, '+').replace(/_/g, '/'), 'base64')
+  const last = bytes.length - 1
+  bytes[last] = (bytes[last] ?? 0) ^ 0x01
+  return bytes.toString('base64url')
+}
+
+describe('OpenCodeServerRegistry', () => {
+  let db: Database
+  let localClient: OpenCodeClient
+  let fetchFn: FetchMock
+  let registry: OpenCodeServerRegistry
+
+  type CreateInput = Parameters<OpenCodeServerRegistry['create']>[0]
+
+  function createServer(overrides: Partial<CreateInput> = {}): Promise<OpenCodeServer> {
+    return registry.create({
+      name: 'Studio',
+      baseUrl: 'https://studio.example.com',
+      username: 'opencode',
+      enabled: true,
+      ...overrides,
+    })
+  }
+
+  beforeEach(() => {
+    db = createTestDb()
+    localClient = createLocalClient()
+    fetchFn = vi.fn(async () => jsonResponse({}))
+    registry = new OpenCodeServerRegistry(db, localClient, fetchFn as unknown as typeof fetch)
+  })
+
+  describe('create', () => {
+    it('creates a server with a normalized base URL and an encrypted password', async () => {
+      const server = await createServer({
+        name: 'Studio',
+        baseUrl: 'https://studio.example.com/',
+        password: 'super-secret',
+      })
+
+      expect(server.id).toMatch(/^srv_[A-Za-z0-9_-]+$/)
+      expect(server.baseUrl).toBe('https://studio.example.com')
+      expect(server.username).toBe('opencode')
+      expect(server.enabled).toBe(true)
+      expect(server.hasPassword).toBe(true)
+      expect(registry.list()).toHaveLength(1)
+
+      const stored = readStoredSecret(db, server.id)
+      expect(stored?.value).not.toBe('super-secret')
+      expect(decryptSecret(stored!.value)).toBe('super-secret')
+      expect(fetchFn).not.toHaveBeenCalled()
+    })
+
+    it('creates a server without a password when none is provided', async () => {
+      const server = await createServer({ name: 'Open', baseUrl: 'http://localhost:4096' })
+
+      expect(server.hasPassword).toBe(false)
+      expect(readStoredSecret(db, server.id)).toBeUndefined()
+    })
+
+    it('redeems a pairing code and stores the returned credentials', async () => {
+      const requests: Array<{ nonce: string; proof: string }> = []
+      fetchFn.mockImplementationOnce(async (_url, init) => {
+        const body = JSON.parse(String(init?.body)) as { nonce: string; proof: string }
+        requests.push(body)
+        return jsonResponse(await encryptOpenCodePairingCredentials({
+          code: PAIR_CODE,
+          nonce: body.nonce,
+          credentials: { username: 'alice', password: 'paired-pass' },
+        }))
+      })
+
+      const server = await createServer({
+        name: 'Paired',
+        baseUrl: 'https://remote.example.com',
+        username: 'ignored',
+        pairing: { pairUrl: PAIR_URL, code: PAIR_CODE },
+      })
+
+      expect(server.username).toBe('alice')
+      expect(server.hasPassword).toBe(true)
+      expect(decryptSecret(readStoredSecret(db, server.id)!.value)).toBe('paired-pass')
+
+      const [url, init] = fetchFn.mock.calls[0]!
+      expect(url).toBe(PAIR_URL)
+      expect(init?.method).toBe('POST')
+      expect(requests).toHaveLength(1)
+      expect(Object.keys(requests[0]!).sort()).toEqual(['nonce', 'proof'])
+      expect(String(init?.body)).not.toContain(PAIR_CODE)
+      await expect(verifyOpenCodePairingProof(PAIR_CODE, requests[0]!.nonce, requests[0]!.proof)).resolves.toBe(true)
+    })
+
+    it('rejects a tampered encrypted payload', async () => {
+      fetchFn.mockImplementationOnce(async (_url, init) => {
+        const { nonce } = JSON.parse(String(init?.body)) as { nonce: string }
+        const encrypted = await encryptOpenCodePairingCredentials({
+          code: PAIR_CODE,
+          nonce,
+          credentials: { username: 'alice', password: 'paired-pass' },
+        })
+        return jsonResponse({ ...encrypted, ciphertext: flipLastByte(encrypted.ciphertext) })
+      })
+
+      const error = await createServer({
+        name: 'Paired',
+        baseUrl: 'https://remote.example.com',
+        pairing: { pairUrl: PAIR_URL, code: PAIR_CODE },
+      }).catch((caught: unknown) => caught)
+
+      expect(error).toBeInstanceOf(OpenCodeServerPairingError)
+      expect((error as { status?: number }).status).toBe(502)
+      expect(registry.list()).toEqual([])
+    })
+
+    it('rejects a response without an encrypted payload', async () => {
+      fetchFn.mockResolvedValueOnce(jsonResponse({ username: 'alice', password: 'paired-pass' }))
+
+      const error = await createServer({
+        name: 'Paired',
+        baseUrl: 'https://remote.example.com',
+        pairing: { pairUrl: PAIR_URL, code: PAIR_CODE },
+      }).catch((caught: unknown) => caught)
+
+      expect(error).toBeInstanceOf(OpenCodeServerPairingError)
+      expect(registry.list()).toEqual([])
+    })
+
+    it('rejects decrypted credentials with an empty username', async () => {
+      fetchFn.mockImplementationOnce(async (_url, init) => {
+        const { nonce } = JSON.parse(String(init?.body)) as { nonce: string }
+        return jsonResponse(await encryptOpenCodePairingCredentials({
+          code: PAIR_CODE,
+          nonce,
+          credentials: { username: '', password: 'paired-pass' },
+        }))
+      })
+
+      const error = await createServer({
+        name: 'Paired',
+        baseUrl: 'https://remote.example.com',
+        pairing: { pairUrl: PAIR_URL, code: PAIR_CODE },
+      }).catch((caught: unknown) => caught)
+
+      expect(error).toBeInstanceOf(OpenCodeServerPairingError)
+      expect(registry.list()).toEqual([])
+    })
+
+    it('fails with a pairing error when the pairing endpoint rejects the code', async () => {
+      fetchFn.mockResolvedValueOnce(new Response(null, { status: 403 }))
+
+      await expect(
+        createServer({
+          name: 'Paired',
+          baseUrl: 'https://remote.example.com',
+          pairing: { pairUrl: PAIR_URL, code: PAIR_CODE },
+        }),
+      ).rejects.toMatchObject({ status: 502 })
+
+      expect(registry.list()).toEqual([])
+      expect(fetchFn).toHaveBeenCalledTimes(1)
+    })
+
+    it('fails with a pairing error when the pairing endpoint is unreachable', async () => {
+      fetchFn.mockRejectedValueOnce(new Error('connect ECONNREFUSED'))
+
+      const error = await createServer({
+        name: 'Paired',
+        baseUrl: 'https://remote.example.com',
+        pairing: { pairUrl: PAIR_URL, code: PAIR_CODE },
+      }).catch((caught: unknown) => caught)
+
+      expect(error).toBeInstanceOf(OpenCodeServerPairingError)
+      expect((error as Error).message).not.toContain(PAIR_CODE)
+    })
+  })
+
+  describe('update', () => {
+    it('updates fields and clears the password when null is sent', async () => {
+      const server = await createServer({
+        name: 'Studio',
+        baseUrl: 'https://studio.example.com',
+        password: 'super-secret',
+      })
+
+      const updated = await registry.update(server.id, { name: 'Renamed', password: null })
+
+      expect(updated.name).toBe('Renamed')
+      expect(updated.hasPassword).toBe(false)
+      expect(readStoredSecret(db, server.id)).toBeUndefined()
+    })
+
+    it('replaces the password when a new one is sent', async () => {
+      const server = await createServer({
+        name: 'Studio',
+        baseUrl: 'https://studio.example.com',
+        password: 'super-secret',
+      })
+
+      await registry.update(server.id, { password: 'next-secret' })
+
+      expect(decryptSecret(readStoredSecret(db, server.id)!.value)).toBe('next-secret')
+    })
+
+    it('throws a not-found error for an unknown server', async () => {
+      await expect(registry.update('srv_missing', { name: 'Renamed' })).rejects.toBeInstanceOf(
+        OpenCodeServerNotFoundError,
+      )
+    })
+
+    it('rejects an origin change that would reuse the stored password', async () => {
+      const server = await createServer({
+        name: 'Studio',
+        baseUrl: 'https://studio.example.com',
+        password: 'super-secret',
+      })
+
+      const error = await registry
+        .update(server.id, { baseUrl: 'https://other-host.example.com' })
+        .catch((caught: unknown) => caught)
+
+      expect(error).toBeInstanceOf(OpenCodeServerCredentialsRequiredError)
+      expect((error as { status?: number }).status).toBe(400)
+      expect((error as Error).message).toBe(
+        'Changing the server address requires re-entering the password or pairing again',
+      )
+      expect(decryptSecret(readStoredSecret(db, server.id)!.value)).toBe('super-secret')
+      expect(registry.get(server.id)?.baseUrl).toBe('https://studio.example.com')
+    })
+
+    it('allows a path change on the same origin without new credentials', async () => {
+      const server = await createServer({
+        name: 'Studio',
+        baseUrl: 'https://studio.example.com',
+        password: 'super-secret',
+      })
+
+      const updated = await registry.update(server.id, { baseUrl: 'https://studio.example.com/opencode/' })
+
+      expect(updated.baseUrl).toBe('https://studio.example.com/opencode')
+      expect(updated.hasPassword).toBe(true)
+      expect(decryptSecret(readStoredSecret(db, server.id)!.value)).toBe('super-secret')
+    })
+
+    it('allows an origin change with a new password', async () => {
+      const server = await createServer({
+        name: 'Studio',
+        baseUrl: 'https://studio.example.com',
+        password: 'super-secret',
+      })
+
+      const updated = await registry.update(server.id, {
+        baseUrl: 'https://other-host.example.com',
+        password: 'next-secret',
+      })
+
+      expect(updated.baseUrl).toBe('https://other-host.example.com')
+      expect(decryptSecret(readStoredSecret(db, server.id)!.value)).toBe('next-secret')
+    })
+
+    it('allows an origin change with an explicit password clear', async () => {
+      const server = await createServer({
+        name: 'Studio',
+        baseUrl: 'https://studio.example.com',
+        password: 'super-secret',
+      })
+
+      const updated = await registry.update(server.id, {
+        baseUrl: 'https://other-host.example.com',
+        password: null,
+      })
+
+      expect(updated.baseUrl).toBe('https://other-host.example.com')
+      expect(updated.hasPassword).toBe(false)
+      expect(readStoredSecret(db, server.id)).toBeUndefined()
+    })
+
+    it('allows an origin change when the server has no stored password', async () => {
+      const server = await createServer({ name: 'Open', baseUrl: 'https://studio.example.com' })
+
+      const updated = await registry.update(server.id, { baseUrl: 'https://other-host.example.com' })
+
+      expect(updated.baseUrl).toBe('https://other-host.example.com')
+      expect(updated.hasPassword).toBe(false)
+    })
+
+    it('allows an origin change with pairing credentials', async () => {
+      fetchFn.mockImplementationOnce(async (_url, init) => {
+        const { nonce } = JSON.parse(String(init?.body)) as { nonce: string }
+        return jsonResponse(await encryptOpenCodePairingCredentials({
+          code: PAIR_CODE,
+          nonce,
+          credentials: { username: 'alice', password: 'paired-pass' },
+        }))
+      })
+      const server = await createServer({
+        name: 'Studio',
+        baseUrl: 'https://studio.example.com',
+        password: 'super-secret',
+      })
+
+      const updated = await registry.update(server.id, {
+        baseUrl: 'https://other-host.example.com',
+        pairing: { pairUrl: PAIR_URL, code: PAIR_CODE },
+      })
+
+      expect(updated.baseUrl).toBe('https://other-host.example.com')
+      expect(updated.username).toBe('alice')
+      expect(decryptSecret(readStoredSecret(db, server.id)!.value)).toBe('paired-pass')
+    })
+  })
+
+  describe('delete', () => {
+    it('removes the server row and its stored password', async () => {
+      const server = await createServer({
+        name: 'Studio',
+        baseUrl: 'https://studio.example.com',
+        password: 'super-secret',
+      })
+
+      registry.delete(server.id)
+
+      expect(registry.get(server.id)).toBeNull()
+      expect(readStoredSecret(db, server.id)).toBeUndefined()
+      expect(() => registry.delete(server.id)).toThrow(OpenCodeServerNotFoundError)
+    })
+  })
+
+  describe('getClient', () => {
+    it('returns the local client for the local server id', async () => {
+      expect(registry.getClient('local')).toBe(localClient)
+    })
+
+    it('caches remote clients and invalidates the cache on update', async () => {
+      const server = await createServer({
+        name: 'Studio',
+        baseUrl: 'https://studio.example.com',
+        password: 'super-secret',
+      })
+
+      const first = registry.getClient(server.id)
+      expect(first).toBeInstanceOf(FetchOpenCodeClient)
+      expect(registry.getClient(server.id)).toBe(first)
+
+      await registry.update(server.id, { name: 'Renamed' })
+
+      const second = registry.getClient(server.id)
+      expect(second).toBeInstanceOf(FetchOpenCodeClient)
+      expect(second).not.toBe(first)
+    })
+
+    it('sends stored basic auth without the local default directory header', async () => {
+      const server = await createServer({
+        name: 'Studio',
+        baseUrl: 'https://studio.example.com',
+        password: 'super-secret',
+      })
+
+      await registry.getClient(server.id).forwardRaw(
+        new Request('http://localhost:5003/api/opencode/api/info'),
+      )
+
+      const headers = new Headers(fetchFn.mock.calls[0]?.[1]?.headers)
+      expect(headers.get('authorization')).toBe(`Basic ${btoa('opencode:super-secret')}`)
+      expect(headers.get('x-opencode-directory')).toBeNull()
+    })
+
+    it('throws a not-found error for unknown and disabled servers', async () => {
+      const server = await createServer({
+        name: 'Studio',
+        baseUrl: 'https://studio.example.com',
+        password: 'super-secret',
+      })
+      await registry.update(server.id, { enabled: false })
+
+      expect(() => registry.getClient('srv_missing')).toThrow(OpenCodeServerNotFoundError)
+      expect(() => registry.getClient(server.id)).toThrow(OpenCodeServerNotFoundError)
+    })
+  })
+
+  describe('getConnection', () => {
+    it('returns the remote base URL and authorization header', async () => {
+      const server = await createServer({
+        name: 'Studio',
+        baseUrl: 'https://studio.example.com/',
+        username: 'alice',
+        password: 'super-secret',
+      })
+
+      expect(registry.getConnection(server.id)).toEqual({
+        baseUrl: 'https://studio.example.com',
+        authorization: `Basic ${btoa('alice:super-secret')}`,
+      })
+    })
+
+    it('rejects the local server id', async () => {
+      expect(() => registry.getConnection('local')).toThrow(OpenCodeServerError)
+    })
+  })
+
+  describe('test', () => {
+    it('reports a supported version', async () => {
+      fetchFn.mockResolvedValueOnce(jsonResponse({ version: '2.0.15' }))
+
+      const result = await registry.test({
+        baseUrl: 'https://studio.example.com/',
+        username: 'alice',
+        password: 'super-secret',
+      })
+
+      expect(result).toEqual({ ok: true, version: '2.0.15', versionSupported: true, error: null })
+      expect(fetchFn.mock.calls[0]?.[0]).toBe('https://studio.example.com/api/info')
+      const headers = new Headers(fetchFn.mock.calls[0]?.[1]?.headers)
+      expect(headers.get('authorization')).toBe(`Basic ${btoa('alice:super-secret')}`)
+    })
+
+    it('reports an unsupported version', async () => {
+      fetchFn.mockResolvedValueOnce(jsonResponse({ version: '1.4.0' }))
+
+      const result = await registry.test({ baseUrl: 'https://studio.example.com', username: 'opencode' })
+
+      expect(result).toEqual({ ok: true, version: '1.4.0', versionSupported: false, error: null })
+    })
+
+    it('uses stored credentials for a server id', async () => {
+      const server = await createServer({
+        name: 'Studio',
+        baseUrl: 'https://studio.example.com',
+        username: 'alice',
+        password: 'super-secret',
+      })
+      fetchFn.mockResolvedValueOnce(jsonResponse({ version: '2.0.15' }))
+
+      const result = await registry.test({ serverId: server.id })
+
+      expect(result.ok).toBe(true)
+      const headers = new Headers(fetchFn.mock.calls[0]?.[1]?.headers)
+      expect(headers.get('authorization')).toBe(`Basic ${btoa('alice:super-secret')}`)
+    })
+
+    it('reuses the stored password for a draft on the same origin', async () => {
+      const server = await createServer({
+        name: 'Studio',
+        baseUrl: 'https://studio.example.com',
+        password: 'super-secret',
+      })
+      fetchFn.mockResolvedValueOnce(jsonResponse({ version: '2.0.15' }))
+
+      const result = await registry.test({
+        baseUrl: 'https://studio.example.com/opencode',
+        username: 'alice',
+        serverId: server.id,
+      })
+
+      expect(result.ok).toBe(true)
+      expect(fetchFn.mock.calls[0]?.[0]).toBe('https://studio.example.com/opencode/api/info')
+      const headers = new Headers(fetchFn.mock.calls[0]?.[1]?.headers)
+      expect(headers.get('authorization')).toBe(`Basic ${btoa('alice:super-secret')}`)
+    })
+
+    it('does not send the stored password to a draft on a different origin', async () => {
+      const server = await createServer({
+        name: 'Studio',
+        baseUrl: 'https://studio.example.com',
+        password: 'super-secret',
+      })
+      fetchFn.mockResolvedValueOnce(jsonResponse({ version: '2.0.15' }))
+
+      const result = await registry.test({
+        baseUrl: 'https://relocated.example.com',
+        username: 'alice',
+        serverId: server.id,
+      })
+
+      expect(result.ok).toBe(true)
+      expect(fetchFn.mock.calls[0]?.[0]).toBe('https://relocated.example.com/api/info')
+      const headers = new Headers(fetchFn.mock.calls[0]?.[1]?.headers)
+      expect(headers.get('authorization')).toBeNull()
+    })
+
+    it('prefers an explicit draft password over the stored one', async () => {
+      const server = await createServer({
+        name: 'Studio',
+        baseUrl: 'https://studio.example.com',
+        password: 'super-secret',
+      })
+      fetchFn.mockResolvedValueOnce(jsonResponse({ version: '2.0.15' }))
+
+      await registry.test({
+        baseUrl: 'https://studio.example.com',
+        username: 'alice',
+        password: 'draft-secret',
+        serverId: server.id,
+      })
+
+      const headers = new Headers(fetchFn.mock.calls[0]?.[1]?.headers)
+      expect(headers.get('authorization')).toBe(`Basic ${btoa('alice:draft-secret')}`)
+    })
+
+    it('throws a not-found error for an unknown server id on a draft', async () => {
+      await expect(
+        registry.test({
+          baseUrl: 'https://studio.example.com',
+          username: 'opencode',
+          serverId: 'srv_missing',
+        }),
+      ).rejects.toBeInstanceOf(OpenCodeServerNotFoundError)
+      expect(fetchFn).not.toHaveBeenCalled()
+    })
+
+    it('reports a failed request without throwing', async () => {
+      fetchFn.mockResolvedValueOnce(new Response(null, { status: 500 }))
+
+      const result = await registry.test({ baseUrl: 'https://studio.example.com', username: 'opencode' })
+
+      expect(result.ok).toBe(false)
+      expect(result.version).toBeNull()
+      expect(result.error).toContain('500')
+    })
+
+    it('reports an unreachable server without throwing', async () => {
+      fetchFn.mockRejectedValueOnce(new Error('connect ECONNREFUSED'))
+
+      const result = await registry.test({ baseUrl: 'https://studio.example.com', username: 'opencode' })
+
+      expect(result).toEqual({
+        ok: false,
+        version: null,
+        versionSupported: false,
+        error: 'Could not reach the OpenCode server',
+      })
+    })
+
+    it('throws a not-found error for an unknown server id', async () => {
+      await expect(registry.test({ serverId: 'srv_missing' })).rejects.toBeInstanceOf(OpenCodeServerNotFoundError)
+    })
+  })
+
+  describe('onChange', () => {
+    it('emits upserted and deleted changes and unsubscribes', async () => {
+      const changes: OpenCodeServerChange[] = []
+      const unsubscribe = registry.onChange((change) => changes.push(change))
+
+      const server = await createServer({ name: 'Studio', baseUrl: 'https://studio.example.com' })
+      registry.delete(server.id)
+      unsubscribe()
+      await createServer({ name: 'Other', baseUrl: 'https://other.example.com' })
+
+      expect(changes).toEqual([
+        { type: 'upserted', serverId: server.id },
+        { type: 'deleted', serverId: server.id },
+      ])
+    })
+  })
+})
diff --git a/backend/src/services/opencode-server-registry.ts b/backend/src/services/opencode-server-registry.ts
new file mode 100644
index 000000000..9c6f27f22
--- /dev/null
+++ b/backend/src/services/opencode-server-registry.ts
@@ -0,0 +1,352 @@
+import type { Database } from 'bun:sqlite'
+import { z } from 'zod'
+import {
+  CreateOpenCodeServerRequestSchema,
+  LOCAL_OPENCODE_SERVER_ID,
+  TestOpenCodeServerRequestSchema,
+  UpdateOpenCodeServerRequestSchema,
+  type OpenCodeServer,
+  type OpenCodeServerPairing,
+  type OpenCodeServerTestResult,
+} from '@opencode-manager/shared/schemas'
+import {
+  buildOpenCodeBasicAuth,
+  createOpenCodePairingNonce,
+  createOpenCodePairingProof,
+  decryptOpenCodePairingCredentials,
+  isSupportedOpenCodeVersion,
+} from '@opencode-manager/shared/opencode'
+import { haveSameUrlOrigin, trimUrlTrailingSlashes } from '@opencode-manager/shared/utils'
+import {
+  deleteOpenCodeServer,
+  getOpenCodeServer,
+  insertOpenCodeServer,
+  listOpenCodeServers,
+  readOpenCodeServerPassword,
+  updateOpenCodeServer,
+} from '../db/opencode-servers'
+import { logger } from '../utils/logger'
+import { ServiceError } from '../utils/service-error'
+import { FetchOpenCodeClient, type OpenCodeClient } from './opencode/client'
+
+const PAIRING_TIMEOUT_MS = 10_000
+const TEST_TIMEOUT_MS = 5_000
+
+const PairingEncryptedPayloadSchema = z.object({
+  iv: z.string().min(1),
+  ciphertext: z.string().min(1),
+})
+
+type CreateServerInput = z.output<typeof CreateOpenCodeServerRequestSchema>
+type UpdateServerInput = z.output<typeof UpdateOpenCodeServerRequestSchema>
+type TestServerInput = z.output<typeof TestOpenCodeServerRequestSchema>
+type TestServerSource = TestServerInput | { serverId: string }
+
+interface TestTarget {
+  baseUrl: string
+  username: string
+  password: string | null
+}
+
+export interface OpenCodeServerChange {
+  type: 'upserted' | 'deleted'
+  serverId: string
+}
+
+export interface OpenCodeServerConnection {
+  baseUrl: string
+  authorization: string | null
+}
+
+export type OpenCodeServerChangeListener = (change: OpenCodeServerChange) => void
+
+export class OpenCodeServerError extends ServiceError {}
+
+export class OpenCodeServerNotFoundError extends OpenCodeServerError {
+  constructor(serverId: string, reason: 'unknown' | 'disabled' = 'unknown') {
+    super(
+      reason === 'disabled' ? `OpenCode server is disabled: ${serverId}` : `OpenCode server not found: ${serverId}`,
+      404,
+    )
+    this.name = 'OpenCodeServerNotFoundError'
+  }
+}
+
+export class OpenCodeServerPairingError extends OpenCodeServerError {
+  constructor(message: string) {
+    super(message, 502)
+    this.name = 'OpenCodeServerPairingError'
+  }
+}
+
+/** Raised when a server address change would reuse stored credentials on a different origin. */
+export class OpenCodeServerCredentialsRequiredError extends OpenCodeServerError {
+  constructor() {
+    super('Changing the server address requires re-entering the password or pairing again', 400)
+    this.name = 'OpenCodeServerCredentialsRequiredError'
+  }
+}
+
+function reusesStoredPasswordOnNewOrigin(server: OpenCodeServer, request: UpdateServerInput): boolean {
+  if (request.baseUrl === undefined) return false
+  if (!server.hasPassword) return false
+  if (request.pairing) return false
+  if (request.password !== undefined) return false
+  return !haveSameUrlOrigin(server.baseUrl, request.baseUrl)
+}
+
+export class OpenCodeServerRegistry {
+  private readonly clients = new Map<string, OpenCodeClient>()
+  private readonly listeners = new Set<OpenCodeServerChangeListener>()
+
+  constructor(
+    private readonly db: Database,
+    private readonly localClient: OpenCodeClient,
+    private readonly fetchFn: typeof fetch = fetch,
+  ) {}
+
+  list(): OpenCodeServer[] {
+    return listOpenCodeServers(this.db)
+  }
+
+  get(serverId: string): OpenCodeServer | null {
+    return getOpenCodeServer(this.db, serverId)
+  }
+
+  async create(request: CreateServerInput): Promise<OpenCodeServer> {
+    const pairing = request.pairing ? await this.redeemPairing(request.pairing) : null
+
+    const server = insertOpenCodeServer(this.db, {
+      name: request.name,
+      baseUrl: request.baseUrl,
+      username: pairing?.username ?? request.username,
+      enabled: request.enabled,
+      password: pairing?.password ?? request.password ?? null,
+    })
+
+    this.emit({ type: 'upserted', serverId: server.id })
+    return server
+  }
+
+  async update(serverId: string, request: UpdateServerInput): Promise<OpenCodeServer> {
+    const existing = this.requireServer(serverId)
+    if (reusesStoredPasswordOnNewOrigin(existing, request)) {
+      throw new OpenCodeServerCredentialsRequiredError()
+    }
+
+    const pairing = request.pairing ? await this.redeemPairing(request.pairing) : null
+
+    const server = updateOpenCodeServer(this.db, serverId, {
+      name: request.name,
+      baseUrl: request.baseUrl,
+      username: pairing?.username ?? request.username,
+      enabled: request.enabled,
+      password: pairing?.password ?? request.password,
+    })
+    if (!server) throw new OpenCodeServerNotFoundError(serverId)
+
+    this.invalidateClient(serverId)
+    this.emit({ type: 'upserted', serverId })
+    return server
+  }
+
+  delete(serverId: string): void {
+    if (!deleteOpenCodeServer(this.db, serverId)) {
+      throw new OpenCodeServerNotFoundError(serverId)
+    }
+
+    this.invalidateClient(serverId)
+    this.emit({ type: 'deleted', serverId })
+  }
+
+  getClient(serverId: string): OpenCodeClient {
+    if (serverId === LOCAL_OPENCODE_SERVER_ID) return this.localClient
+
+    const cached = this.clients.get(serverId)
+    if (cached) return cached
+
+    const connection = this.getConnection(serverId)
+    const client = new FetchOpenCodeClient({
+      baseUrl: connection.baseUrl,
+      basicAuth: connection.authorization,
+      defaultDirectory: false,
+      fetchFn: this.fetchFn,
+    })
+
+    this.clients.set(serverId, client)
+    return client
+  }
+
+  getConnection(serverId: string): OpenCodeServerConnection {
+    if (serverId === LOCAL_OPENCODE_SERVER_ID) {
+      throw new OpenCodeServerError('The local OpenCode server has no remote connection', 400)
+    }
+
+    const server = this.requireServer(serverId)
+    if (!server.enabled) throw new OpenCodeServerNotFoundError(serverId, 'disabled')
+
+    const password = readOpenCodeServerPassword(this.db, serverId)
+    return {
+      baseUrl: server.baseUrl,
+      authorization: password === null ? null : buildOpenCodeBasicAuth(password, server.username),
+    }
+  }
+
+  async test(input: TestServerSource): Promise<OpenCodeServerTestResult> {
+    const target = this.resolveTestTarget(input)
+    const headers: Record<string, string> = { Accept: 'application/json' }
+    if (target.password !== null) {
+      headers.Authorization = buildOpenCodeBasicAuth(target.password, target.username)
+    }
+
+    let response: Response
+    try {
+      response = await this.fetchFn(`${target.baseUrl}/api/info`, {
+        headers,
+        signal: AbortSignal.timeout(TEST_TIMEOUT_MS),
+      })
+    } catch {
+      return {
+        ok: false,
+        version: null,
+        versionSupported: false,
+        error: 'Could not reach the OpenCode server',
+      }
+    }
+
+    if (!response.ok) {
+      return {
+        ok: false,
+        version: null,
+        versionSupported: false,
+        error: `OpenCode server responded with status ${response.status}`,
+      }
+    }
+
+    const version = await this.readServerVersion(response)
+    if (version === null) {
+      return {
+        ok: false,
+        version: null,
+        versionSupported: false,
+        error: 'OpenCode server returned an invalid response',
+      }
+    }
+
+    return {
+      ok: true,
+      version,
+      versionSupported: isSupportedOpenCodeVersion(version),
+      error: null,
+    }
+  }
+
+  onChange(listener: OpenCodeServerChangeListener): () => void {
+    this.listeners.add(listener)
+    return () => {
+      this.listeners.delete(listener)
+    }
+  }
+
+  private resolveTestTarget(input: TestServerSource): TestTarget {
+    if (!('baseUrl' in input)) {
+      const server = this.requireServer(input.serverId)
+      return {
+        baseUrl: server.baseUrl,
+        username: server.username,
+        password: readOpenCodeServerPassword(this.db, input.serverId),
+      }
+    }
+
+    const baseUrl = trimUrlTrailingSlashes(input.baseUrl)
+    if (input.password !== undefined || input.serverId === undefined) {
+      return {
+        baseUrl,
+        username: input.username,
+        password: input.password ?? null,
+      }
+    }
+
+    const server = this.requireServer(input.serverId)
+    return {
+      baseUrl,
+      username: input.username,
+      password: haveSameUrlOrigin(server.baseUrl, baseUrl)
+        ? readOpenCodeServerPassword(this.db, input.serverId)
+        : null,
+    }
+  }
+
+  private async readServerVersion(response: Response): Promise<string | null> {
+    try {
+      const body = (await response.json()) as { version?: unknown }
+      return typeof body.version === 'string' && body.version.length > 0 ? body.version : null
+    } catch {
+      return null
+    }
+  }
+
+  private async redeemPairing(pairing: OpenCodeServerPairing): Promise<{ username: string; password: string }> {
+    const nonce = createOpenCodePairingNonce()
+    const proof = await createOpenCodePairingProof(pairing.code, nonce)
+
+    let response: Response
+    try {
+      response = await this.fetchFn(pairing.pairUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ nonce, proof }),
+        signal: AbortSignal.timeout(PAIRING_TIMEOUT_MS),
+      })
+    } catch {
+      throw new OpenCodeServerPairingError('Could not reach the pairing endpoint')
+    }
+
+    if (response.status !== 200) {
+      throw new OpenCodeServerPairingError(`Pairing was rejected with status ${response.status}`)
+    }
+
+    let payload: unknown
+    try {
+      payload = await response.json()
+    } catch {
+      throw new OpenCodeServerPairingError('Pairing returned an invalid response')
+    }
+
+    const parsed = PairingEncryptedPayloadSchema.safeParse(payload)
+    if (!parsed.success) {
+      throw new OpenCodeServerPairingError('Pairing returned an invalid response')
+    }
+
+    try {
+      return await decryptOpenCodePairingCredentials({
+        code: pairing.code,
+        nonce,
+        iv: parsed.data.iv,
+        ciphertext: parsed.data.ciphertext,
+      })
+    } catch {
+      throw new OpenCodeServerPairingError('Pairing returned invalid credentials')
+    }
+  }
+
+  private requireServer(serverId: string): OpenCodeServer {
+    const server = getOpenCodeServer(this.db, serverId)
+    if (!server) throw new OpenCodeServerNotFoundError(serverId)
+    return server
+  }
+
+  private invalidateClient(serverId: string): void {
+    this.clients.delete(serverId)
+  }
+
+  private emit(change: OpenCodeServerChange): void {
+    for (const listener of this.listeners) {
+      try {
+        listener(change)
+      } catch (error) {
+        logger.error('OpenCode server change listener failed', error)
+      }
+    }
+  }
+}
diff --git a/backend/src/services/opencode/client.ts b/backend/src/services/opencode/client.ts
index 98777a4af..8dc63166a 100644
--- a/backend/src/services/opencode/client.ts
+++ b/backend/src/services/opencode/client.ts
@@ -1,7 +1,7 @@
 import { logger } from '../../utils/logger'
 import { ENV } from '@opencode-manager/shared/config/env'
 import { createOpenCodeApi, type OpenCodeApi } from '@opencode-manager/shared/opencode'
-import { filterProxyHeaders } from '../../utils/proxy-headers'
+import { filterProxyHeaders, NULL_BODY_STATUSES } from '../../utils/proxy-headers'
 import { getOpenCodeBasicAuthHeader, type OpenCodePasswordResolver } from './auth'
 import { getOpenCodeUpstreamBaseUrl, withDefaultOpenCodeDirectory } from './upstream'
 
@@ -17,6 +17,7 @@ export interface FetchOpenCodeClientConfig {
   basicAuth: string | null
   passwordResolver?: OpenCodePasswordResolver
   fetchFn?: typeof fetch
+  defaultDirectory?: boolean
 }
 
 export class FetchOpenCodeClient implements OpenCodeClient {
@@ -45,8 +46,12 @@ export class FetchOpenCodeClient implements OpenCodeClient {
     return await getOpenCodeBasicAuthHeader(this.config.passwordResolver)
   }
 
+  private withDirectoryHeader(headers: Record<string, string>): Record<string, string> {
+    return this.config.defaultDirectory === false ? headers : withDefaultOpenCodeDirectory(headers)
+  }
+
   private async fetchWithResolvedAuth(input: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]): Promise<Response> {
-    const headers = new Headers(withDefaultOpenCodeDirectory(Object.fromEntries(new Headers(init?.headers))))
+    const headers = new Headers(this.withDirectoryHeader(Object.fromEntries(new Headers(init?.headers))))
     const basicAuth = await this.getBasicAuth()
 
     if (basicAuth) {
@@ -59,7 +64,7 @@ export class FetchOpenCodeClient implements OpenCodeClient {
   private async request(req: { method: string; path: string; body?: string; headers?: Record<string, string> }): Promise<Response> {
     const url = new URL(this.resolveBaseUrl() + req.path)
 
-    const headers: Record<string, string> = withDefaultOpenCodeDirectory({ ...(req.headers ?? {}) })
+    const headers: Record<string, string> = this.withDirectoryHeader({ ...(req.headers ?? {}) })
 
     const basicAuth = await this.getBasicAuth()
 
@@ -76,8 +81,7 @@ export class FetchOpenCodeClient implements OpenCodeClient {
 
       const filteredHeaders = filterProxyHeaders(response.headers)
 
-      const noBodyStatuses = new Set([101, 204, 205, 304])
-      if (noBodyStatuses.has(response.status)) {
+      if (NULL_BODY_STATUSES.has(response.status)) {
         return new Response(null, {
           status: response.status,
           statusText: response.statusText,
diff --git a/backend/src/services/remote-server-events.ts b/backend/src/services/remote-server-events.ts
new file mode 100644
index 000000000..0d48cc127
--- /dev/null
+++ b/backend/src/services/remote-server-events.ts
@@ -0,0 +1,428 @@
+import { EventSource } from 'eventsource'
+import { DEFAULTS } from '@opencode-manager/shared/config'
+import {
+  buildServerDirectoryKey,
+  LOCAL_OPENCODE_SERVER_ID,
+  type OpenCodeServer,
+  type OpenCodeServerStatus,
+} from '@opencode-manager/shared/schemas'
+import { type OpenCodeApi, type V2Event } from '@opencode-manager/shared/opencode'
+import { logger } from '../utils/logger'
+import type {
+  OpenCodeServerChange,
+  OpenCodeServerConnection,
+  OpenCodeServerRegistry,
+} from './opencode-server-registry'
+import {
+  collectPendingReplayEvents,
+  createAuthorizedEventSourceInit,
+  createReplayEventBuilder,
+  nextBackoffDelay,
+  parseOpenCodeEvent,
+  planSessionStatusReplay,
+  type ReplayEventBuilder,
+} from './opencode-event-routing'
+import type { RemoteReplayHandler } from './sse-aggregator'
+
+const { RECONNECT_DELAY_MS, MAX_RECONNECT_DELAY_MS } = DEFAULTS.SSE
+
+export interface RemoteEventAggregator {
+  deliverRemoteEnvelope(serverId: string, directory: string | null, payloadJson: string): void
+  deliverRemoteEnvelopeToClient(clientId: string, serverId: string, directory: string, payloadJson: string): void
+  sendRemoteResync(serverId: string): void
+  hasClientDirectory(clientId: string, key: string): boolean
+  setRemoteReplayHandler(handler: RemoteReplayHandler | null): void
+}
+
+export interface RemoteEventSource {
+  onopen: ((event: unknown) => void) | null
+  onerror: ((event: unknown) => void) | null
+  onmessage: ((event: { data: string }) => void) | null
+  close(): void
+}
+
+export type RemoteEventSourceInit = ConstructorParameters<typeof EventSource>[1]
+export type RemoteEventSourceFactory = (url: string, init?: RemoteEventSourceInit) => RemoteEventSource
+
+export interface RemoteServerEventHubOptions {
+  eventSourceFactory?: RemoteEventSourceFactory
+  reconnectDelayMs?: number
+  maxReconnectDelayMs?: number
+}
+
+interface RemoteServerStream {
+  source: RemoteEventSource | null
+  reconnectTimeout: ReturnType<typeof setTimeout> | null
+  reconnectDelay: number
+  connected: boolean
+  error: string | null
+  version: string | null
+  versionRequested: boolean
+  versionProbeToken: number
+  sessionDirectories: Map<string, string>
+}
+
+function createDefaultEventSource(url: string, init?: RemoteEventSourceInit): RemoteEventSource {
+  return new EventSource(url, init) as unknown as RemoteEventSource
+}
+
+function describeStreamError(error: unknown): string {
+  if (typeof error === 'string' && error) return error
+  if (error instanceof Error && error.message) return error.message
+  if (typeof error === 'object' && error !== null) {
+    const { message, code } = error as { message?: unknown; code?: unknown }
+    if (typeof message === 'string' && message) return message
+    if (typeof code === 'number' || typeof code === 'string') return `event stream closed (code=${String(code)})`
+  }
+  return 'event stream disconnected'
+}
+
+export class RemoteServerEventHub {
+  private readonly streams = new Map<string, RemoteServerStream>()
+  private readonly eventSourceFactory: RemoteEventSourceFactory
+  private readonly reconnectDelayMs: number
+  private readonly maxReconnectDelayMs: number
+  private unsubscribeRegistry: (() => void) | null = null
+  private started = false
+  private versionProbeSequence = 0
+  private readonly buildReplayEvent: ReplayEventBuilder = createReplayEventBuilder('ocm_replay_remote_')
+
+  constructor(
+    private readonly registry: OpenCodeServerRegistry,
+    private readonly aggregator: RemoteEventAggregator,
+    options: RemoteServerEventHubOptions = {},
+  ) {
+    this.eventSourceFactory = options.eventSourceFactory ?? createDefaultEventSource
+    this.reconnectDelayMs = options.reconnectDelayMs ?? RECONNECT_DELAY_MS
+    this.maxReconnectDelayMs = options.maxReconnectDelayMs ?? MAX_RECONNECT_DELAY_MS
+  }
+
+  start(): void {
+    if (this.started) return
+    this.started = true
+    this.aggregator.setRemoteReplayHandler((clientId, serverId, directory) =>
+      this.replayPendingActions(clientId, serverId, directory))
+    this.unsubscribeRegistry = this.registry.onChange(change => this.handleRegistryChange(change))
+    this.connectAll()
+  }
+
+  shutdown(): void {
+    this.started = false
+    if (this.unsubscribeRegistry) {
+      this.unsubscribeRegistry()
+      this.unsubscribeRegistry = null
+    }
+    for (const serverId of Array.from(this.streams.keys())) {
+      this.forgetStream(serverId)
+    }
+    this.aggregator.setRemoteReplayHandler(null)
+  }
+
+  getStatuses(): OpenCodeServerStatus[] {
+    let servers: OpenCodeServer[]
+    try {
+      servers = this.registry.list()
+    } catch (error) {
+      logger.error('Failed to list OpenCode servers for remote event status', error)
+      return []
+    }
+
+    return servers.map(server => {
+      const stream = this.streams.get(server.id)
+      return {
+        serverId: server.id,
+        connected: stream?.connected ?? false,
+        version: stream?.version ?? null,
+        error: stream?.error ?? null,
+      }
+    })
+  }
+
+  async replayPendingActions(clientId: string, serverId: string, directory: string): Promise<void> {
+    const key = buildServerDirectoryKey(serverId, directory)
+    if (!this.aggregator.hasClientDirectory(clientId, key)) return
+
+    let api: OpenCodeApi
+    try {
+      api = this.registry.getClient(serverId).api
+    } catch (error) {
+      logger.warn(`remote replay: no client for ${serverId}: ${String(error)}`)
+      return
+    }
+
+    const events = await collectPendingReplayEvents({
+      api,
+      directory,
+      buildEvent: this.buildReplayEvent,
+      logScope: 'remote replay',
+      logTarget: key,
+    })
+
+    this.emitReplayEventsToClient(clientId, serverId, directory, events.permissions)
+    this.emitReplayEventsToClient(clientId, serverId, directory, events.forms)
+  }
+
+  private emitReplayEventsToClient(
+    clientId: string,
+    serverId: string,
+    directory: string,
+    events: V2Event[],
+  ): void {
+    for (const event of events) {
+      this.aggregator.deliverRemoteEnvelopeToClient(clientId, serverId, directory, JSON.stringify(event))
+    }
+  }
+
+  private connectAll(): void {
+    let servers: OpenCodeServer[]
+    try {
+      servers = this.registry.list()
+    } catch (error) {
+      logger.error('Failed to list OpenCode servers for remote event streams', error)
+      return
+    }
+
+    for (const server of servers) {
+      if (server.id === LOCAL_OPENCODE_SERVER_ID) continue
+      if (server.enabled) this.connectServer(server.id)
+    }
+  }
+
+  private connectServer(serverId: string): void {
+    if (!this.started) return
+    this.closeStream(serverId)
+
+    let connection: OpenCodeServerConnection
+    try {
+      connection = this.registry.getConnection(serverId)
+    } catch (error) {
+      this.recordError(serverId, describeStreamError(error))
+      logger.warn(`Remote event stream unavailable for ${serverId}: ${describeStreamError(error)}`)
+      return
+    }
+
+    const authorization = connection.authorization
+    const init: RemoteEventSourceInit = createAuthorizedEventSourceInit(authorization)
+
+    const stream = this.ensureStream(serverId)
+    let source: RemoteEventSource
+    try {
+      source = this.eventSourceFactory(`${connection.baseUrl}/api/event`, init)
+    } catch (error) {
+      this.recordError(serverId, describeStreamError(error))
+      this.scheduleReconnect(serverId)
+      return
+    }
+
+    stream.source = source
+    stream.error = null
+    source.onopen = () => this.handleOpen(serverId, source)
+    source.onerror = (event) => this.handleStreamError(serverId, source, event)
+    source.onmessage = (event) => this.handleMessage(serverId, event.data)
+    logger.info(`Remote event stream connecting: ${serverId}`)
+  }
+
+  private handleOpen(serverId: string, source: RemoteEventSource): void {
+    const stream = this.streams.get(serverId)
+    if (!stream || stream.source !== source) return
+
+    stream.connected = true
+    stream.error = null
+    stream.reconnectDelay = this.reconnectDelayMs
+    logger.info(`Remote event stream connected: ${serverId}`)
+    this.aggregator.sendRemoteResync(serverId)
+    void this.refreshVersion(serverId)
+    void this.replaySessionStatuses(serverId, source)
+  }
+
+  private handleStreamError(serverId: string, source: RemoteEventSource, error: unknown): void {
+    const stream = this.streams.get(serverId)
+    if (!stream || stream.source !== source) return
+
+    stream.connected = false
+    stream.error = describeStreamError(error)
+    logger.warn(`Remote event stream error for ${serverId}: ${stream.error}`)
+    this.closeSource(stream)
+    this.scheduleReconnect(serverId)
+  }
+
+  private scheduleReconnect(serverId: string): void {
+    const stream = this.streams.get(serverId)
+    if (!this.started || !stream || stream.reconnectTimeout) return
+
+    const delay = stream.reconnectDelay
+    stream.reconnectTimeout = setTimeout(() => {
+      const current = this.streams.get(serverId)
+      if (!current) return
+      current.reconnectTimeout = null
+      current.reconnectDelay = nextBackoffDelay(current.reconnectDelay, this.maxReconnectDelayMs)
+      this.connectServer(serverId)
+    }, delay)
+  }
+
+  private handleMessage(serverId: string, data: string): void {
+    const stream = this.streams.get(serverId)
+    if (!stream) return
+
+    const routed = parseOpenCodeEvent(data, stream.sessionDirectories)
+    if (!routed) return
+
+    try {
+      this.aggregator.deliverRemoteEnvelope(serverId, routed.resolvedDirectory ?? null, routed.payloadJson)
+    } catch (error) {
+      logger.error(`Remote event stream failed to handle ${routed.event.type} for ${serverId}:`, error)
+    }
+  }
+
+  private handleRegistryChange(change: OpenCodeServerChange): void {
+    if (!this.started) return
+
+    if (change.type === 'deleted') {
+      this.forgetStream(change.serverId)
+      return
+    }
+
+    let server: OpenCodeServer | null
+    try {
+      server = this.registry.get(change.serverId)
+    } catch (error) {
+      logger.warn(`Failed to read OpenCode server ${change.serverId}: ${String(error)}`)
+      this.forgetStream(change.serverId)
+      return
+    }
+
+    if (!server || !server.enabled) {
+      this.forgetStream(change.serverId)
+      return
+    }
+
+    const stream = this.streams.get(change.serverId)
+    if (stream) {
+      stream.reconnectDelay = this.reconnectDelayMs
+      stream.version = null
+      stream.versionRequested = false
+      stream.versionProbeToken = 0
+    }
+    this.connectServer(change.serverId)
+  }
+
+  private isStreamCurrent(serverId: string, stream: RemoteServerStream, source: RemoteEventSource): boolean {
+    return this.streams.get(serverId) === stream && stream.source === source && stream.connected
+  }
+
+  private async replaySessionStatuses(serverId: string, source: RemoteEventSource): Promise<void> {
+    const stream = this.streams.get(serverId)
+    if (!stream || !this.isStreamCurrent(serverId, stream, source)) return
+
+    let api: OpenCodeApi
+    try {
+      api = this.registry.getClient(serverId).api
+    } catch (error) {
+      logger.warn(`remote status replay: no client for ${serverId}: ${String(error)}`)
+      return
+    }
+
+    let active: Record<string, unknown>
+    try {
+      active = await api.session.active()
+    } catch (error) {
+      logger.warn(`remote status replay: failed to fetch active sessions for ${serverId}: ${String(error)}`)
+      return
+    }
+
+    if (!this.isStreamCurrent(serverId, stream, source)) return
+
+    const plan = planSessionStatusReplay(active, stream.sessionDirectories)
+    let replayed = 0
+
+    for (const { sessionID, directory } of plan.idle) {
+      const event = this.buildReplayEvent('session.status', directory, { sessionID, status: { type: 'idle' } })
+      this.aggregator.deliverRemoteEnvelope(serverId, directory, JSON.stringify(event))
+      replayed++
+    }
+
+    for (const sessionID of plan.busy) {
+      const directory = stream.sessionDirectories.get(sessionID) ?? null
+      const event = this.buildReplayEvent('session.status', directory ?? '', { sessionID, status: { type: 'busy' } })
+      this.aggregator.deliverRemoteEnvelope(serverId, directory, JSON.stringify(event))
+      replayed++
+    }
+
+    if (replayed > 0) {
+      logger.info(`remote status replay: re-emitted ${replayed} session status(es) for ${serverId}`)
+    }
+  }
+
+  private async refreshVersion(serverId: string): Promise<void> {
+    const stream = this.streams.get(serverId)
+    if (!stream || stream.versionRequested) return
+
+    this.versionProbeSequence += 1
+    const token = this.versionProbeSequence
+    stream.versionRequested = true
+    stream.versionProbeToken = token
+
+    let version: string | null = null
+    try {
+      const result = await this.registry.test({ serverId })
+      version = result.ok && result.version ? result.version : null
+    } catch (error) {
+      logger.warn(`Failed to read the version of OpenCode server ${serverId}: ${String(error)}`)
+    }
+
+    const current = this.streams.get(serverId)
+    if (!current || current.versionProbeToken !== token) return
+    if (version) {
+      current.version = version
+      return
+    }
+    current.versionRequested = false
+  }
+
+  private ensureStream(serverId: string): RemoteServerStream {
+    const existing = this.streams.get(serverId)
+    if (existing) return existing
+
+    const stream: RemoteServerStream = {
+      source: null,
+      reconnectTimeout: null,
+      reconnectDelay: this.reconnectDelayMs,
+      connected: false,
+      error: null,
+      version: null,
+      versionRequested: false,
+      versionProbeToken: 0,
+      sessionDirectories: new Map(),
+    }
+    this.streams.set(serverId, stream)
+    return stream
+  }
+
+  private recordError(serverId: string, error: string): void {
+    const stream = this.ensureStream(serverId)
+    stream.connected = false
+    stream.error = error
+  }
+
+  private closeSource(stream: RemoteServerStream): void {
+    if (!stream.source) return
+    stream.source.close()
+    stream.source = null
+  }
+
+  private closeStream(serverId: string): void {
+    const stream = this.streams.get(serverId)
+    if (!stream) return
+    if (stream.reconnectTimeout) {
+      clearTimeout(stream.reconnectTimeout)
+      stream.reconnectTimeout = null
+    }
+    this.closeSource(stream)
+    stream.connected = false
+  }
+
+  private forgetStream(serverId: string): void {
+    this.closeStream(serverId)
+    this.streams.delete(serverId)
+  }
+}
diff --git a/backend/src/services/settings.ts b/backend/src/services/settings.ts
index 7dd427d79..cee87177d 100644
--- a/backend/src/services/settings.ts
+++ b/backend/src/services/settings.ts
@@ -2,7 +2,8 @@ import { Database } from 'bun:sqlite'
 import { randomBytes } from 'node:crypto'
 import { logger } from '../utils/logger'
 import { parseJsonc } from '@opencode-manager/shared/utils'
-import { encryptSecret, decryptSecret } from '../utils/crypto'
+import { encryptSecret } from '../utils/crypto'
+import { deleteSecret, readEncryptedSecret, writeEncryptedSecret } from '../db/secrets'
 import { ENV } from '@opencode-manager/shared/config/env'
 import type {
   UserPreferences,
@@ -142,16 +143,7 @@ export class SettingsService {
   }
 
   private readSecret(key: string): string | null {
-    const row = this.db.prepare('SELECT value FROM app_secrets WHERE key = ?').get(key) as { value: string } | undefined
-    if (!row) {
-      return null
-    }
-    try {
-      return decryptSecret(row.value)
-    } catch (error) {
-      logger.error(`Failed to decrypt ${key}`, error)
-      return null
-    }
+    return readEncryptedSecret(this.db, key)
   }
 
   getOrCreateManagedOpenCodeServerPassword(): string {
@@ -218,15 +210,10 @@ export class SettingsService {
   }
 
   setOpenCodeServerPassword(password: string): void {
-    const now = Date.now()
-    const encrypted = encryptSecret(password)
-    this.db.prepare(`
-      INSERT INTO app_secrets (key, value, created_at, updated_at) VALUES (?, ?, ?, ?)
-      ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
-    `).run(CUSTOM_OPENCODE_SERVER_PASSWORD_KEY, encrypted, now, now)
+    writeEncryptedSecret(this.db, CUSTOM_OPENCODE_SERVER_PASSWORD_KEY, password)
   }
 
   clearOpenCodeServerPassword(): void {
-    this.db.prepare('DELETE FROM app_secrets WHERE key = ?').run(CUSTOM_OPENCODE_SERVER_PASSWORD_KEY)
+    deleteSecret(this.db, CUSTOM_OPENCODE_SERVER_PASSWORD_KEY)
   }
 }
diff --git a/backend/src/services/sse-aggregator.ts b/backend/src/services/sse-aggregator.ts
index 4b5cedd50..097b24459 100644
--- a/backend/src/services/sse-aggregator.ts
+++ b/backend/src/services/sse-aggregator.ts
@@ -1,15 +1,27 @@
 import { EventSource } from 'eventsource'
 import { logger } from '../utils/logger'
 import { DEFAULTS } from '@opencode-manager/shared/config'
-import { openCodeLocation, sessionIDFromEvent, type OpenCodeApi, type V2Event } from '@opencode-manager/shared/opencode'
+import { buildServerDirectoryKey, LOCAL_OPENCODE_SERVER_ID, parseServerDirectoryKey } from '@opencode-manager/shared/schemas'
+import { type OpenCodeApi, type V2Event } from '@opencode-manager/shared/opencode'
 import { getOpenCodeBasicAuthHeader, type OpenCodePasswordResolver } from './opencode/auth'
 import { getOpenCodeUpstreamBaseUrl } from './opencode/upstream'
 import { encodeSSEFrame } from '../utils/sse-frame'
+import {
+  collectPendingReplayEvents,
+  createAuthorizedEventSourceInit,
+  createReplayEventBuilder,
+  nextBackoffDelay,
+  parseOpenCodeEvent,
+  planSessionStatusReplay,
+  type ReplayEventBuilder,
+} from './opencode-event-routing'
 
 type SSEClientCallback = (event: string, data: string) => void
 type SSEClientFrameWriter = (frame: Uint8Array) => void
 type SSEEventListener = (directory: string | null, event: SSEEvent) => void
 
+export type RemoteReplayHandler = (clientId: string, serverId: string, directory: string) => void | Promise<void>
+
 interface SSEClient {
   id: string
   callback: SSEClientCallback
@@ -30,14 +42,12 @@ export interface ScheduledSessionRef {
   directory: string
 }
 
-type ReplayEventType = 'permission.asked' | 'form.created' | 'session.status'
-
 const { RECONNECT_DELAY_MS, MAX_RECONNECT_DELAY_MS } = DEFAULTS.SSE
-const MULTILINE_PATTERN = /[\r\n]/
 const LOCATION_CATALOG_EVENT_TYPES = new Set(['command.updated', 'agent.updated', 'skill.updated', 'model.updated', 'provider.updated', 'integration.updated'])
 
-function serializeEnvelope(directory: string | null, payloadJson: string): string {
-  return '{"directory":' + JSON.stringify(directory) + ',"payload":' + payloadJson + '}'
+function serializeEnvelope(directory: string | null, payloadJson: string, serverId?: string): string {
+  const serverField = serverId === undefined ? '' : ',"serverId":' + JSON.stringify(serverId)
+  return '{"directory":' + JSON.stringify(directory) + serverField + ',"payload":' + payloadJson + '}'
 }
 
 class SSEAggregator {
@@ -58,7 +68,8 @@ class SSEAggregator {
   private pendingActionsFetcher: PendingActionsFetcher | null = null
   private passwordResolver: OpenCodePasswordResolver | null = null
   private scheduledSessionsResolver: (() => ScheduledSessionRef[]) | null = null
-  private replayEventCount = 0
+  private remoteReplayHandler: RemoteReplayHandler | null = null
+  private readonly buildReplayEvent: ReplayEventBuilder = createReplayEventBuilder('ocm_replay_')
 
   private constructor() {}
 
@@ -74,6 +85,10 @@ class SSEAggregator {
     this.scheduledSessionsResolver = resolver
   }
 
+  setRemoteReplayHandler(handler: RemoteReplayHandler | null): void {
+    this.remoteReplayHandler = handler
+  }
+
   reconnect(): void {
     if (!this.started) return
     logger.info('SSE forcing upstream reconnect (auth changed)')
@@ -118,7 +133,7 @@ class SSEAggregator {
     logger.info(`Client ${id} connected with directories: ${directories.length > 0 ? directories.join(', ') : '(none)'}`)
 
     if (directories.length > 0) {
-      void this.replayPendingActionsForClient(id, directories)
+      this.replayForDirectories(id, directories)
     }
 
     return () => this.removeClient(id)
@@ -127,7 +142,10 @@ class SSEAggregator {
   removeClient(id: string): void {
     const client = this.clients.get(id)
     if (client) {
-      client.directories.forEach(dir => this.deindexClientDirectory(id, dir))
+      for (const directory of Array.from(client.directories)) {
+        client.directories.delete(directory)
+        this.deindexClientDirectory(id, directory)
+      }
     }
     this.clients.delete(id)
   }
@@ -149,7 +167,7 @@ class SSEAggregator {
     logger.info(`Client ${clientId} subscribed to: ${directories.join(', ')}`)
 
     if (newDirectories.length > 0) {
-      void this.replayPendingActionsForClient(clientId, newDirectories)
+      this.replayForDirectories(clientId, newDirectories)
     }
 
     return true
@@ -185,6 +203,44 @@ class SSEAggregator {
     if (set.size === 0) this.directoryClients.delete(directory)
   }
 
+  private replayForDirectories(clientId: string, directories: string[]): void {
+    const localDirectories: string[] = []
+    const remoteDirectories: Array<{ serverId: string; directory: string }> = []
+
+    for (const directory of directories) {
+      const parsed = parseServerDirectoryKey(directory)
+      if (parsed.serverId === LOCAL_OPENCODE_SERVER_ID) {
+        localDirectories.push(directory)
+      } else {
+        remoteDirectories.push(parsed)
+      }
+    }
+
+    if (localDirectories.length > 0) {
+      void this.replayPendingActionsForClient(clientId, localDirectories)
+    }
+
+    const handler = this.remoteReplayHandler
+    if (!handler) return
+
+    for (const { serverId, directory } of remoteDirectories) {
+      void this.replayRemoteDirectory(clientId, serverId, directory, handler)
+    }
+  }
+
+  private async replayRemoteDirectory(
+    clientId: string,
+    serverId: string,
+    directory: string,
+    handler: RemoteReplayHandler,
+  ): Promise<void> {
+    try {
+      await handler(clientId, serverId, directory)
+    } catch (error) {
+      logger.warn(`remote replay: failed for ${buildServerDirectoryKey(serverId, directory)}: ${String(error)}`)
+    }
+  }
+
   private async replayPendingActionsForClient(clientId: string, directories: string[]): Promise<void> {
     const fetcher = this.pendingActionsFetcher
     if (!fetcher) return
@@ -199,26 +255,16 @@ class SSEAggregator {
     directory: string,
     fetcher: PendingActionsFetcher,
   ): Promise<void> {
-    const [permissionsResult, formsResult] = await Promise.allSettled([
-      fetcher.api.permission.request.list(openCodeLocation(directory)),
-      fetcher.api.form.list(openCodeLocation(directory)),
-    ])
-
-    if (permissionsResult.status === 'rejected') {
-      logger.warn(`replay: failed to fetch pending permissions for ${directory}: ${String(permissionsResult.reason)}`)
-    } else {
-      this.emitReplayEventsToClient(clientId, directory, permissionsResult.value.data.map(request =>
-        this.buildReplayEvent('permission.asked', directory, request)
-      ))
-    }
+    const events = await collectPendingReplayEvents({
+      api: fetcher.api,
+      directory,
+      buildEvent: this.buildReplayEvent,
+      logScope: 'replay',
+      logTarget: directory,
+    })
 
-    if (formsResult.status === 'rejected') {
-      logger.warn(`replay: failed to fetch pending forms for ${directory}: ${String(formsResult.reason)}`)
-    } else {
-      this.emitReplayEventsToClient(clientId, directory, formsResult.value.data.map(form =>
-        this.buildReplayEvent('form.created', directory, { form })
-      ))
-    }
+    this.emitReplayEventsToClient(clientId, directory, events.permissions)
+    this.emitReplayEventsToClient(clientId, directory, events.forms)
   }
 
   private emitReplayEventsToClient(clientId: string, directory: string, events: V2Event[]): void {
@@ -252,18 +298,16 @@ class SSEAggregator {
     }
 
     const tracked = this.getTrackedSessions()
-    const runningIDs = Object.keys(running ?? {})
-    const runningSet = new Set(runningIDs)
+    const plan = planSessionStatusReplay(running, tracked)
 
     let replayed = 0
 
-    for (const [sessionID, directory] of tracked) {
-      if (runningSet.has(sessionID)) continue
+    for (const { sessionID, directory } of plan.idle) {
       this.deliverEvent(directory, this.buildReplayEvent('session.status', directory, { sessionID, status: { type: 'idle' } }))
       replayed++
     }
 
-    const runningDirectories = await Promise.all(runningIDs.map(async (sessionID) => ({
+    const runningDirectories = await Promise.all(plan.busy.map(async (sessionID) => ({
       sessionID,
       directory: tracked.get(sessionID) ?? await this.resolveSessionDirectory(fetcher, sessionID),
     })))
@@ -302,17 +346,6 @@ class SSEAggregator {
     }
   }
 
-  private buildReplayEvent(type: ReplayEventType, directory: string, data: unknown): V2Event {
-    this.replayEventCount += 1
-    return {
-      id: `ocm_replay_${this.replayEventCount}`,
-      created: Date.now(),
-      type,
-      location: { directory },
-      data,
-    } as V2Event
-  }
-
   private async connectUpstream(): Promise<void> {
     if (!this.started) return
     if (this.upstream) {
@@ -330,18 +363,7 @@ class SSEAggregator {
 
     if (!this.started) return
 
-    const init: ConstructorParameters<typeof EventSource>[1] = authHeader
-      ? {
-          fetch: (input, fetchInit) =>
-            fetch(input, {
-              ...fetchInit,
-              headers: {
-                ...(fetchInit?.headers ?? {}),
-                Authorization: authHeader,
-              },
-            }),
-        }
-      : undefined
+    const init: ConstructorParameters<typeof EventSource>[1] = createAuthorizedEventSourceInit(authHeader)
 
     const es = new EventSource(url, init)
     this.upstream = es
@@ -393,7 +415,7 @@ class SSEAggregator {
     if (!this.started || this.reconnectTimeout) return
     this.reconnectTimeout = setTimeout(() => {
       this.reconnectTimeout = null
-      this.reconnectDelay = Math.min(this.reconnectDelay * 2, MAX_RECONNECT_DELAY_MS)
+      this.reconnectDelay = nextBackoffDelay(this.reconnectDelay, MAX_RECONNECT_DELAY_MS)
       void this.connectUpstream()
     }, this.reconnectDelay)
   }
@@ -409,31 +431,12 @@ class SSEAggregator {
   }
 
   private handleUpstreamMessage(data: string): void {
-    let event: V2Event
-    try {
-      event = JSON.parse(data) as V2Event
-    } catch {
-      return
-    }
-
-    if (!event?.type) return
+    const routed = parseOpenCodeEvent(data, this.sessionDirectories)
+    if (!routed) return
 
-    const payloadJson = MULTILINE_PATTERN.test(data) ? JSON.stringify(event) : data
-    const directory = event.location?.directory
-    const sessionID = sessionIDFromEvent(event)
-    const forkParentId = event.type === 'session.forked' ? event.data.parentID : undefined
-    const inheritedDirectory = forkParentId ? this.sessionDirectories.get(forkParentId) : undefined
+    const { event, payloadJson, directory, resolvedDirectory } = routed
 
     try {
-      const rememberedDirectory = directory ?? inheritedDirectory
-      const resolvedDirectory = rememberedDirectory ?? (sessionID ? this.sessionDirectories.get(sessionID) : undefined)
-
-      if (sessionID && event.type === 'session.deleted') {
-        this.sessionDirectories.delete(sessionID)
-      } else if (sessionID && rememberedDirectory) {
-        this.sessionDirectories.set(sessionID, rememberedDirectory)
-      }
-
       if (directory) {
         if (LOCATION_CATALOG_EVENT_TYPES.has(event.type)) {
           this.deliverResolvedEvent(directory, event, payloadJson)
@@ -486,12 +489,65 @@ class SSEAggregator {
       const client = this.clients.get(clientId)
       if (!client) continue
       frame ??= encodeSSEFrame('message', serializeEnvelope(directory, payloadJson))
+      this.writeFrame(client, frame, 'Failed to send to client')
+    }
+  }
+
+  private writeFrame(client: SSEClient, frame: Uint8Array, errorLabel: string): void {
+    try {
+      client.writeFrame(frame)
+    } catch (error) {
+      logger.error(`${errorLabel} ${client.id}:`, error)
+    }
+  }
+
+  hasClientDirectory(clientId: string, key: string): boolean {
+    return this.clients.get(clientId)?.directories.has(key) ?? false
+  }
+
+  deliverRemoteEnvelope(serverId: string, directory: string | null, payloadJson: string): void {
+    const clientIds = directory === null
+      ? this.clientIdsForServer(serverId)
+      : Array.from(this.directoryClients.get(buildServerDirectoryKey(serverId, directory)) ?? [])
+    if (clientIds.length === 0) return
+    const frame = encodeSSEFrame('message', serializeEnvelope(directory, payloadJson, serverId))
+    for (const clientId of clientIds) {
+      const client = this.clients.get(clientId)
+      if (!client) continue
+      this.writeFrame(client, frame, 'Failed to send remote event to client')
+    }
+  }
+
+  deliverRemoteEnvelopeToClient(clientId: string, serverId: string, directory: string, payloadJson: string): void {
+    if (!this.hasClientDirectory(clientId, buildServerDirectoryKey(serverId, directory))) return
+    const client = this.clients.get(clientId)
+    if (!client) return
+    const frame = encodeSSEFrame('message', serializeEnvelope(directory, payloadJson, serverId))
+    this.writeFrame(client, frame, 'Failed to send remote event to client')
+  }
+
+  sendRemoteResync(serverId: string): void {
+    const data = JSON.stringify({ timestamp: Date.now(), serverId })
+    for (const clientId of this.clientIdsForServer(serverId)) {
+      const client = this.clients.get(clientId)
+      if (!client) continue
       try {
-        client.writeFrame(frame)
-      } catch (error) {
-        logger.error(`Failed to send to client ${client.id}:`, error)
+        client.callback('resync', data)
+      } catch { /* ignore resync errors */ }
+    }
+  }
+
+  private clientIdsForServer(serverId: string): string[] {
+    const clientIds: string[] = []
+    for (const client of this.clients.values()) {
+      for (const key of client.directories) {
+        if (parseServerDirectoryKey(key).serverId === serverId) {
+          clientIds.push(client.id)
+          break
+        }
       }
     }
+    return clientIds
   }
 
   private handleEvent(directory: string, event: SSEEvent): void {
@@ -652,6 +708,7 @@ class SSEAggregator {
     this.clients.clear()
     this.eventListeners.clear()
     this.upstreamConnectedListeners.clear()
+    this.remoteReplayHandler = null
   }
 
   broadcastToAll(event: string, data: string): void {
diff --git a/backend/src/utils/proxy-headers.ts b/backend/src/utils/proxy-headers.ts
index 6dc9fa6ac..3db799bf5 100644
--- a/backend/src/utils/proxy-headers.ts
+++ b/backend/src/utils/proxy-headers.ts
@@ -1,3 +1,5 @@
+export const NULL_BODY_STATUSES: ReadonlySet<number> = new Set([101, 204, 205, 304])
+
 const HOP_BY_HOP_HEADERS = new Set([
   'connection',
   'keep-alive',
diff --git a/backend/test/index.test.ts b/backend/test/index.test.ts
index a2b120cee..2b4fa3cdb 100644
--- a/backend/test/index.test.ts
+++ b/backend/test/index.test.ts
@@ -126,6 +126,7 @@ const sseAggregatorMock = vi.hoisted(() => ({
   setPendingActionsFetcher: vi.fn(),
   setPasswordResolver: vi.fn(),
   setScheduledSessionsResolver: vi.fn(),
+  setRemoteReplayHandler: vi.fn(),
   start: vi.fn(),
   shutdown: vi.fn(),
   reconnect: vi.fn(),
diff --git a/backend/test/routes/opencode-server-proxy.test.ts b/backend/test/routes/opencode-server-proxy.test.ts
new file mode 100644
index 000000000..fb7cea9ae
--- /dev/null
+++ b/backend/test/routes/opencode-server-proxy.test.ts
@@ -0,0 +1,247 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { Hono } from 'hono'
+import type { MiddlewareHandler } from 'hono'
+import { createOpenCodeServerProxyRoutes } from '../../src/routes/opencode-server-proxy'
+import {
+  OpenCodeServerError,
+  OpenCodeServerNotFoundError,
+  type OpenCodeServerRegistry,
+} from '../../src/services/opencode-server-registry'
+
+const getConnectionMock = vi.hoisted(() => vi.fn())
+
+const registry = { getConnection: getConnectionMock } as unknown as OpenCodeServerRegistry
+
+const basicAuth = `Basic ${Buffer.from('opencode:secret').toString('base64')}`
+
+const passThroughAuth: MiddlewareHandler = async (_c, next) => {
+  await next()
+}
+
+function buildApp(
+  fetchFn: typeof fetch,
+  requireAuth: MiddlewareHandler = passThroughAuth,
+): Hono {
+  const app = new Hono()
+  app.route('/api/opencode/servers', createOpenCodeServerProxyRoutes(registry, requireAuth, fetchFn))
+  return app
+}
+
+function createFetchMock(response: Response = new Response('ok', { status: 200 })) {
+  return vi.fn().mockResolvedValue(response)
+}
+
+function readBody(body: RequestInit['body']): Promise<string> {
+  return new Response(body as unknown as string).text()
+}
+
+describe('opencode server proxy routes', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    getConnectionMock.mockReturnValue({ baseUrl: 'https://remote.example:4096', authorization: basicAuth })
+  })
+
+  it('forwards method, path, query, and streamed body to the upstream with registry credentials', async () => {
+    const fetchMock = createFetchMock()
+    const app = buildApp(fetchMock as unknown as typeof fetch)
+    const payload = JSON.stringify({ parts: [{ type: 'text', text: 'hi' }] })
+
+    const res = await app.request('/api/opencode/servers/srv_1/api/session/ses_1/message?directory=%2Fwork', {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        cookie: 'session=cookie-value',
+        host: 'manager.local',
+        authorization: 'Bearer client-token',
+        origin: 'https://manager.local',
+        referer: 'https://manager.local/chat',
+      },
+      body: payload,
+    })
+
+    expect(res.status).toBe(200)
+    expect(fetchMock).toHaveBeenCalledTimes(1)
+
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(url).toBe('https://remote.example:4096/api/session/ses_1/message?directory=%2Fwork')
+    expect(init.method).toBe('POST')
+    expect(init.redirect).toBe('manual')
+    expect(await readBody(init.body)).toBe(payload)
+
+    const headers = init.headers as Record<string, string>
+    expect(headers.Authorization).toBe(basicAuth)
+    expect(headers['content-type']).toBe('application/json')
+    const headerNames = Object.keys(headers).map((name) => name.toLowerCase())
+    expect(headerNames).not.toContain('cookie')
+    expect(headerNames).not.toContain('host')
+    expect(headerNames).not.toContain('origin')
+    expect(headerNames).not.toContain('referer')
+    expect(headerNames).not.toContain('x-opencode-directory')
+    expect(headerNames.filter((name) => name === 'authorization')).toHaveLength(1)
+  })
+
+  it('does not add a default directory header on GET requests', async () => {
+    const fetchMock = createFetchMock()
+    const app = buildApp(fetchMock as unknown as typeof fetch)
+
+    await app.request('/api/opencode/servers/srv_1/api/session', { method: 'GET' })
+
+    const [, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    const headers = init.headers as Record<string, string>
+    expect(Object.keys(headers).map((name) => name.toLowerCase())).not.toContain('x-opencode-directory')
+    expect(init.body).toBeUndefined()
+  })
+
+  it('returns 404 for an unknown server', async () => {
+    getConnectionMock.mockImplementation(() => {
+      throw new OpenCodeServerNotFoundError('srv_missing')
+    })
+    const fetchMock = createFetchMock()
+    const app = buildApp(fetchMock as unknown as typeof fetch)
+
+    const res = await app.request('/api/opencode/servers/srv_missing/api/session')
+
+    expect(res.status).toBe(404)
+    expect(await res.json()).toEqual({ error: 'OpenCode server not found: srv_missing' })
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+
+  it('returns 404 for a disabled server', async () => {
+    getConnectionMock.mockImplementation(() => {
+      throw new OpenCodeServerNotFoundError('srv_off', 'disabled')
+    })
+    const fetchMock = createFetchMock()
+    const app = buildApp(fetchMock as unknown as typeof fetch)
+
+    const res = await app.request('/api/opencode/servers/srv_off/api/session')
+
+    expect(res.status).toBe(404)
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+
+  it('returns 400 for the local server', async () => {
+    getConnectionMock.mockImplementation(() => {
+      throw new OpenCodeServerError('The local OpenCode server has no remote connection', 400)
+    })
+    const fetchMock = createFetchMock()
+    const app = buildApp(fetchMock as unknown as typeof fetch)
+
+    const res = await app.request('/api/opencode/servers/local/api/session')
+
+    expect(res.status).toBe(400)
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+
+  it('returns 400 for encoded traversal segments', async () => {
+    const fetchMock = createFetchMock()
+    const app = buildApp(fetchMock as unknown as typeof fetch)
+
+    const res = await app.request('/api/opencode/servers/srv_1/api/session%2F..%2Fsecrets')
+
+    expect(res.status).toBe(400)
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+
+  it('returns 400 for repeated encoded traversal that survives segment decoding', async () => {
+    const fetchMock = createFetchMock()
+    const app = buildApp(fetchMock as unknown as typeof fetch)
+
+    const res = await app.request('/api/opencode/servers/srv_1/api/%25252e%25252e/config')
+
+    expect(res.status).toBe(400)
+    expect(await res.json()).toEqual({ error: 'Invalid proxy path' })
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+
+  it('returns 400 when a prefixed base URL would be escaped by path normalization', async () => {
+    getConnectionMock.mockReturnValue({ baseUrl: 'http://remote.example:4096/prefix', authorization: basicAuth })
+    const fetchMock = createFetchMock()
+    const app = buildApp(fetchMock as unknown as typeof fetch)
+
+    const res = await app.request(
+      '/api/opencode/servers/srv_1/api/session/%25252e%25252e/%25252e%25252e/config',
+    )
+
+    expect(res.status).toBe(400)
+    expect(await res.json()).toEqual({ error: 'Invalid proxy path' })
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+
+  it('proxies a normal API path under a prefixed base URL unchanged', async () => {
+    getConnectionMock.mockReturnValue({ baseUrl: 'http://remote.example:4096/prefix', authorization: basicAuth })
+    const fetchMock = createFetchMock()
+    const app = buildApp(fetchMock as unknown as typeof fetch)
+
+    const res = await app.request('/api/opencode/servers/srv_1/api/session')
+
+    expect(res.status).toBe(200)
+    expect(fetchMock).toHaveBeenCalledTimes(1)
+    const [url] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(url).toBe('http://remote.example:4096/prefix/api/session')
+  })
+
+  it('returns 404 for upstream paths outside /api', async () => {
+    const fetchMock = createFetchMock()
+    const app = buildApp(fetchMock as unknown as typeof fetch)
+
+    const res = await app.request('/api/opencode/servers/srv_1/config')
+
+    expect(res.status).toBe(404)
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+
+  it('returns 502 when the upstream fetch fails', async () => {
+    const fetchMock = vi.fn().mockRejectedValue(new Error('connect ECONNREFUSED'))
+    const app = buildApp(fetchMock as unknown as typeof fetch)
+
+    const res = await app.request('/api/opencode/servers/srv_1/api/session')
+
+    expect(res.status).toBe(502)
+    expect(await res.json()).toEqual({ error: 'Remote OpenCode server unreachable' })
+  })
+
+  it('streams the upstream response body and drops set-cookie', async () => {
+    const encoder = new TextEncoder()
+    const stream = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(encoder.encode('data: one\n\n'))
+        controller.enqueue(encoder.encode('data: two\n\n'))
+        controller.close()
+      },
+    })
+    const fetchMock = createFetchMock(new Response(stream, {
+      status: 200,
+      headers: { 'content-type': 'text/event-stream', 'set-cookie': 'leak=1' },
+    }))
+    const app = buildApp(fetchMock as unknown as typeof fetch)
+
+    const res = await app.request('/api/opencode/servers/srv_1/api/event')
+
+    expect(res.status).toBe(200)
+    expect(res.headers.get('content-type')).toBe('text/event-stream')
+    expect(res.headers.get('set-cookie')).toBeNull()
+    expect(await res.text()).toBe('data: one\n\ndata: two\n\n')
+  })
+
+  it('returns a null body for bodyless upstream statuses', async () => {
+    const fetchMock = createFetchMock(new Response(null, { status: 204 }))
+    const app = buildApp(fetchMock as unknown as typeof fetch)
+
+    const res = await app.request('/api/opencode/servers/srv_1/api/session/ses_1', { method: 'DELETE' })
+
+    expect(res.status).toBe(204)
+    expect(await res.text()).toBe('')
+  })
+
+  it('rejects unauthenticated requests before reaching the upstream', async () => {
+    const fetchMock = createFetchMock()
+    const denyAuth: MiddlewareHandler = async (c) => c.json({ error: 'Unauthorized' }, 401)
+    const app = buildApp(fetchMock as unknown as typeof fetch, denyAuth)
+
+    const res = await app.request('/api/opencode/servers/srv_1/api/session')
+
+    expect(res.status).toBe(401)
+    expect(fetchMock).not.toHaveBeenCalled()
+    expect(getConnectionMock).not.toHaveBeenCalled()
+  })
+})
diff --git a/backend/test/routes/opencode-servers.test.ts b/backend/test/routes/opencode-servers.test.ts
new file mode 100644
index 000000000..7a2d28990
--- /dev/null
+++ b/backend/test/routes/opencode-servers.test.ts
@@ -0,0 +1,258 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { createOpenCodeServerRoutes } from '../../src/routes/opencode-servers'
+import {
+  OpenCodeServerCredentialsRequiredError,
+  OpenCodeServerNotFoundError,
+  OpenCodeServerPairingError,
+  type OpenCodeServerRegistry,
+} from '../../src/services/opencode-server-registry'
+
+const SERVER = {
+  id: 'srv_1',
+  name: 'Studio',
+  baseUrl: 'https://studio.example.com',
+  username: 'opencode',
+  enabled: true,
+  hasPassword: true,
+  createdAt: 1,
+  updatedAt: 1,
+}
+
+const TEST_RESULT = { ok: true, version: '2.0.15', versionSupported: true, error: null }
+
+describe('opencode server routes', () => {
+  const registry = {
+    list: vi.fn(),
+    get: vi.fn(),
+    create: vi.fn(),
+    update: vi.fn(),
+    delete: vi.fn(),
+    test: vi.fn(),
+  }
+  let app: ReturnType<typeof createOpenCodeServerRoutes>
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    registry.list.mockReturnValue([])
+    registry.get.mockReturnValue(null)
+    app = createOpenCodeServerRoutes(registry as unknown as OpenCodeServerRegistry, () => [])
+  })
+
+  it('lists servers', async () => {
+    registry.list.mockReturnValue([SERVER])
+
+    const response = await app.request('/')
+
+    expect(response.status).toBe(200)
+    expect(await response.json()).toEqual({ servers: [SERVER] })
+  })
+
+  it('returns 404 for an unknown server id', async () => {
+    const response = await app.request('/srv_missing')
+
+    expect(response.status).toBe(404)
+  })
+
+  it('returns the server for a known id', async () => {
+    registry.get.mockReturnValue(SERVER)
+
+    const response = await app.request('/srv_1')
+
+    expect(response.status).toBe(200)
+    expect(await response.json()).toEqual({ server: SERVER })
+  })
+
+  it('returns 400 for an invalid create body', async () => {
+    const response = await app.request('/', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'Studio' }),
+    })
+
+    expect(response.status).toBe(400)
+    expect(registry.create).not.toHaveBeenCalled()
+  })
+
+  it('returns 400 for an invalid draft test body', async () => {
+    const response = await app.request('/test', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ baseUrl: 'ftp://studio.example.com' }),
+    })
+
+    expect(response.status).toBe(400)
+  })
+
+  it('returns 400 for an invalid update body', async () => {
+    const response = await app.request('/srv_1', {
+      method: 'PATCH',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: '' }),
+    })
+
+    expect(response.status).toBe(400)
+    expect(registry.update).not.toHaveBeenCalled()
+  })
+
+  it('creates a server and returns its test result', async () => {
+    registry.create.mockResolvedValue(SERVER)
+    registry.test.mockResolvedValue(TEST_RESULT)
+
+    const response = await app.request('/', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'Studio', baseUrl: 'https://studio.example.com', password: 'super-secret' }),
+    })
+
+    expect(response.status).toBe(201)
+    expect(await response.json()).toEqual({ server: SERVER, test: TEST_RESULT })
+    expect(registry.create).toHaveBeenCalledWith({
+      name: 'Studio',
+      baseUrl: 'https://studio.example.com',
+      username: 'opencode',
+      password: 'super-secret',
+      enabled: true,
+    })
+    expect(registry.test).toHaveBeenCalledWith({ serverId: 'srv_1' })
+  })
+
+  it('returns 502 when pairing fails', async () => {
+    registry.create.mockRejectedValue(new OpenCodeServerPairingError('Pairing was rejected with status 403'))
+
+    const response = await app.request('/', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        name: 'Studio',
+        baseUrl: 'https://studio.example.com',
+        pairing: { pairUrl: 'https://studio.example.com/pair', code: '0123456789abcdef' },
+      }),
+    })
+
+    expect(response.status).toBe(502)
+  })
+
+  it('updates a server', async () => {
+    registry.update.mockResolvedValue({ ...SERVER, name: 'Renamed' })
+
+    const response = await app.request('/srv_1', {
+      method: 'PATCH',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'Renamed' }),
+    })
+
+    expect(response.status).toBe(200)
+    expect(registry.update).toHaveBeenCalledWith('srv_1', { name: 'Renamed' })
+  })
+
+  it('returns 400 when an origin change would reuse the stored password', async () => {
+    registry.update.mockRejectedValue(new OpenCodeServerCredentialsRequiredError())
+
+    const response = await app.request('/srv_1', {
+      method: 'PATCH',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ baseUrl: 'https://other-host.example.com' }),
+    })
+
+    expect(response.status).toBe(400)
+    expect(await response.json()).toEqual({
+      error: 'Changing the server address requires re-entering the password or pairing again',
+    })
+  })
+
+  it('returns 404 when updating an unknown server', async () => {
+    registry.update.mockRejectedValue(new OpenCodeServerNotFoundError('srv_missing'))
+
+    const response = await app.request('/srv_missing', {
+      method: 'PATCH',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'Renamed' }),
+    })
+
+    expect(response.status).toBe(404)
+  })
+
+  it('deletes a server', async () => {
+    const response = await app.request('/srv_1', { method: 'DELETE' })
+
+    expect(response.status).toBe(204)
+    expect(registry.delete).toHaveBeenCalledWith('srv_1')
+  })
+
+  it('returns 404 when deleting an unknown server', async () => {
+    registry.delete.mockImplementation(() => {
+      throw new OpenCodeServerNotFoundError('srv_missing')
+    })
+
+    const response = await app.request('/srv_missing', { method: 'DELETE' })
+
+    expect(response.status).toBe(404)
+  })
+
+  it('tests a stored server', async () => {
+    registry.test.mockResolvedValue(TEST_RESULT)
+
+    const response = await app.request('/srv_1/test', { method: 'POST' })
+
+    expect(response.status).toBe(200)
+    expect(await response.json()).toEqual(TEST_RESULT)
+    expect(registry.test).toHaveBeenCalledWith({ serverId: 'srv_1' })
+  })
+
+  it('tests a draft server', async () => {
+    registry.test.mockResolvedValue(TEST_RESULT)
+
+    const response = await app.request('/test', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ baseUrl: 'https://studio.example.com' }),
+    })
+
+    expect(response.status).toBe(200)
+    expect(await response.json()).toEqual(TEST_RESULT)
+    expect(registry.test).toHaveBeenCalledWith({ baseUrl: 'https://studio.example.com', username: 'opencode' })
+  })
+
+  it('tests a draft server against a saved server id', async () => {
+    registry.test.mockResolvedValue(TEST_RESULT)
+
+    const response = await app.request('/test', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ baseUrl: 'https://studio.example.com/opencode', serverId: 'srv_1' }),
+    })
+
+    expect(response.status).toBe(200)
+    expect(registry.test).toHaveBeenCalledWith({
+      baseUrl: 'https://studio.example.com/opencode',
+      username: 'opencode',
+      serverId: 'srv_1',
+    })
+  })
+
+  it('returns 404 when testing a draft against an unknown server id', async () => {
+    registry.test.mockRejectedValue(new OpenCodeServerNotFoundError('srv_missing'))
+
+    const response = await app.request('/test', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ baseUrl: 'https://studio.example.com', serverId: 'srv_missing' }),
+    })
+
+    expect(response.status).toBe(404)
+    expect(await response.json()).toEqual({ error: 'OpenCode server not found: srv_missing' })
+  })
+
+  it('returns the remote event statuses from the provider', async () => {
+    const statuses = [{ serverId: 'srv_1', connected: true, version: '2.0.15', error: null }]
+    const statusApp = createOpenCodeServerRoutes(
+      registry as unknown as OpenCodeServerRegistry,
+      () => statuses,
+    )
+
+    const response = await statusApp.request('/status')
+
+    expect(response.status).toBe(200)
+    expect(await response.json()).toEqual({ statuses })
+  })
+})
diff --git a/backend/test/routes/sse.test.ts b/backend/test/routes/sse.test.ts
index b6ad20704..ed5f7dd4c 100644
--- a/backend/test/routes/sse.test.ts
+++ b/backend/test/routes/sse.test.ts
@@ -121,6 +121,25 @@ describe('SSE Routes', () => {
       )
       expect(cleanup).toHaveBeenCalledTimes(1)
     })
+
+    it('registers remote server directory keys unchanged', async () => {
+      const directories = ['/local', 'srv_a|/remote', 'srv_b|/other']
+      const res = await app.fetch(new Request(`http://localhost/stream?directories=${encodeURIComponent(directories.join(','))}`))
+      const reader = res.body!.getReader()
+      try {
+        const first = await readChunk(reader)
+        expect(first).toContain(JSON.stringify(directories))
+      } finally {
+        await reader.cancel()
+      }
+
+      expect(sseMocks.addClient).toHaveBeenCalledWith(
+        expect.stringMatching(/^client_/),
+        expect.any(Function),
+        expect.any(Function),
+        directories,
+      )
+    })
   })
 
   describe('POST /subscribe', () => {
diff --git a/backend/test/services/remote-server-events.test.ts b/backend/test/services/remote-server-events.test.ts
new file mode 100644
index 000000000..afe98cd84
--- /dev/null
+++ b/backend/test/services/remote-server-events.test.ts
@@ -0,0 +1,918 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('../../src/utils/logger', () => ({
+  logger: {
+    info: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+  },
+}))
+
+import type { OpenCodeApi } from '@opencode-manager/shared/opencode'
+import type { OpenCodeServer, OpenCodeServerTestResult } from '@opencode-manager/shared/schemas'
+import { sseAggregator } from '../../src/services/sse-aggregator'
+import {
+  RemoteServerEventHub,
+  type RemoteEventSource,
+  type RemoteEventSourceFactory,
+  type RemoteEventSourceInit,
+} from '../../src/services/remote-server-events'
+import type {
+  OpenCodeServerChange,
+  OpenCodeServerConnection,
+  OpenCodeServerRegistry,
+} from '../../src/services/opencode-server-registry'
+
+const SERVER_A: OpenCodeServer = {
+  id: 'srv_a',
+  name: 'Studio',
+  baseUrl: 'https://studio.example.com',
+  username: 'opencode',
+  enabled: true,
+  hasPassword: true,
+  createdAt: 1,
+  updatedAt: 1,
+}
+
+const SERVER_B: OpenCodeServer = {
+  id: 'srv_b',
+  name: 'Laptop',
+  baseUrl: 'https://laptop.example.com',
+  username: 'opencode',
+  enabled: true,
+  hasPassword: false,
+  createdAt: 1,
+  updatedAt: 1,
+}
+
+class FakeEventSource implements RemoteEventSource {
+  onopen: ((event: unknown) => void) | null = null
+  onerror: ((event: unknown) => void) | null = null
+  onmessage: ((event: { data: string }) => void) | null = null
+  closed = false
+
+  constructor(
+    readonly url: string,
+    readonly init?: RemoteEventSourceInit,
+  ) {}
+
+  close(): void {
+    this.closed = true
+  }
+
+  open(): void {
+    this.onopen?.({})
+  }
+
+  fail(event: unknown = { message: 'connection lost' }): void {
+    this.onerror?.(event)
+  }
+
+  message(data: string): void {
+    this.onmessage?.({ data })
+  }
+}
+
+interface CapturedClient {
+  events: Array<{ event: string; data: string }>
+  frames: string[]
+  callback: (event: string, data: string) => void
+  writeFrame: (frame: Uint8Array) => void
+}
+
+function createCapturingClient(): CapturedClient {
+  const events: Array<{ event: string; data: string }> = []
+  const frames: string[] = []
+  const decoder = new TextDecoder()
+  return {
+    events,
+    frames,
+    callback: (event, data) => { events.push({ event, data }) },
+    writeFrame: (frame) => { frames.push(decoder.decode(frame)) },
+  }
+}
+
+function parseFrame(frame: string): {
+  directory: string | null
+  serverId?: string
+  payload: { id?: string; type: string; data: Record<string, unknown> }
+} {
+  return JSON.parse(frame.replace(/^event: message\ndata: /, '').trim())
+}
+
+interface ApiFixture {
+  permissions?: Record<string, unknown[]>
+  forms?: Record<string, unknown[]>
+  active?: Record<string, { type: 'running' }>
+}
+
+function makeApi(fixture: ApiFixture = {}): OpenCodeApi {
+  const directoryOf = (input?: { location?: { directory?: string } }): string => input?.location?.directory ?? ''
+
+  return {
+    permission: {
+      request: {
+        list: vi.fn(async (input?: { location?: { directory?: string } }) => ({
+          location: { directory: directoryOf(input) },
+          data: fixture.permissions?.[directoryOf(input)] ?? [],
+        })),
+      },
+    },
+    form: {
+      list: vi.fn(async (input?: { location?: { directory?: string } }) => ({
+        location: { directory: directoryOf(input) },
+        data: fixture.forms?.[directoryOf(input)] ?? [],
+      })),
+    },
+    session: {
+      active: vi.fn(async () => fixture.active ?? {}),
+    },
+  } as unknown as OpenCodeApi
+}
+
+interface FakeRegistry {
+  registry: OpenCodeServerRegistry
+  api: OpenCodeApi
+  emit: (change: OpenCodeServerChange) => void
+  setServer: (server: OpenCodeServer) => void
+  removeServer: (serverId: string) => void
+  listCalls: () => number
+}
+
+function createRegistry(servers: OpenCodeServer[], fixture: ApiFixture = {}): FakeRegistry {
+  const byId = new Map(servers.map(server => [server.id, server]))
+  const listeners = new Set<(change: OpenCodeServerChange) => void>()
+  const api = makeApi(fixture)
+  let listCalls = 0
+
+  const registry = {
+    list: () => {
+      listCalls += 1
+      return Array.from(byId.values())
+    },
+    get: (serverId: string) => byId.get(serverId) ?? null,
+    getConnection: (serverId: string): OpenCodeServerConnection => {
+      const server = byId.get(serverId)
+      if (!server) throw new Error(`OpenCode server not found: ${serverId}`)
+      if (!server.enabled) throw new Error(`OpenCode server is disabled: ${serverId}`)
+      return {
+        baseUrl: server.baseUrl,
+        authorization: server.hasPassword ? 'Basic dXNlcjpwYXNz' : null,
+      }
+    },
+    getClient: () => ({ api }),
+    onChange: (listener: (change: OpenCodeServerChange) => void) => {
+      listeners.add(listener)
+      return () => { listeners.delete(listener) }
+    },
+    test: vi.fn(async () => ({ ok: true, version: '2.0.15', versionSupported: true, error: null })),
+  } as unknown as OpenCodeServerRegistry
+
+  return {
+    registry,
+    api,
+    emit: (change) => { listeners.forEach(listener => listener(change)) },
+    setServer: (server) => { byId.set(server.id, server) },
+    removeServer: (serverId) => { byId.delete(serverId) },
+    listCalls: () => listCalls,
+  }
+}
+
+function createSourceFactory() {
+  const sources: FakeEventSource[] = []
+  const factory: RemoteEventSourceFactory = (url, init) => {
+    const source = new FakeEventSource(url, init)
+    sources.push(source)
+    return source
+  }
+  return {
+    sources,
+    factory,
+    latest: () => sources[sources.length - 1]!,
+  }
+}
+
+async function flushPromises(): Promise<void> {
+  for (let i = 0; i < 10; i++) {
+    await Promise.resolve()
+  }
+}
+
+function remoteEvent(type: string, data: unknown, directory?: string): string {
+  return JSON.stringify({
+    id: 'evt_1',
+    created: 1,
+    type,
+    ...(directory ? { location: { directory } } : {}),
+    data,
+  })
+}
+
+describe('RemoteServerEventHub event delivery', () => {
+  let hub: RemoteServerEventHub
+  let fake: FakeRegistry
+  let sources: ReturnType<typeof createSourceFactory>
+
+  beforeEach(() => {
+    sseAggregator.shutdown()
+    sseAggregator.setPendingActionsFetcher(null)
+    sseAggregator.setScheduledSessionsResolver(() => [])
+    fake = createRegistry([SERVER_A, SERVER_B])
+    sources = createSourceFactory()
+    hub = new RemoteServerEventHub(fake.registry, sseAggregator, { eventSourceFactory: sources.factory })
+  })
+
+  afterEach(() => {
+    hub.shutdown()
+    sseAggregator.shutdown()
+  })
+
+  it('opens one stream per enabled server with the connection authorization', () => {
+    hub.start()
+
+    expect(sources.sources.map(source => source.url)).toEqual([
+      'https://studio.example.com/api/event',
+      'https://laptop.example.com/api/event',
+    ])
+    expect(sources.sources[0]?.init?.fetch).toBeTypeOf('function')
+    expect(sources.sources[1]?.init).toBeUndefined()
+  })
+
+  it('delivers a located event only to clients subscribed to that server and directory, with a serverId envelope', () => {
+    const remoteClient = createCapturingClient()
+    const otherServerClient = createCapturingClient()
+    const localClient = createCapturingClient()
+    sseAggregator.addClient('remote-a', remoteClient.callback, remoteClient.writeFrame, ['srv_a|/repo'])
+    sseAggregator.addClient('remote-b', otherServerClient.callback, otherServerClient.writeFrame, ['srv_b|/repo'])
+    sseAggregator.addClient('local-a', localClient.callback, localClient.writeFrame, ['/repo'])
+
+    const listener = vi.fn()
+    sseAggregator.onEvent(listener)
+
+    hub.start()
+    const source = sources.sources[0]!
+    source.open()
+    remoteClient.frames.length = 0
+
+    source.message(remoteEvent('session.idle', { sessionID: 'ses_1' }, '/repo'))
+
+    expect(remoteClient.frames.map(parseFrame)).toEqual([{
+      directory: '/repo',
+      serverId: 'srv_a',
+      payload: {
+        id: 'evt_1',
+        created: 1,
+        type: 'session.idle',
+        location: { directory: '/repo' },
+        data: { sessionID: 'ses_1' },
+      },
+    }])
+    expect(otherServerClient.frames).toHaveLength(0)
+    expect(localClient.frames).toHaveLength(0)
+    expect(listener).not.toHaveBeenCalled()
+    expect(sseAggregator.getActiveSessions()).toEqual({})
+  })
+
+  it('resolves a directory-less event through the per-server session map', () => {
+    const client = createCapturingClient()
+    sseAggregator.addClient('session-map', client.callback, client.writeFrame, ['srv_a|/repo'])
+
+    hub.start()
+    const source = sources.sources[0]!
+    source.message(remoteEvent('session.created', { sessionID: 'ses_1', parentID: null }, '/repo'))
+    client.frames.length = 0
+
+    source.message(remoteEvent('session.execution.succeeded', { sessionID: 'ses_1' }))
+
+    expect(client.frames.map(parseFrame)).toEqual([{
+      directory: '/repo',
+      serverId: 'srv_a',
+      payload: {
+        id: 'evt_1',
+        created: 1,
+        type: 'session.execution.succeeded',
+        data: { sessionID: 'ses_1' },
+      },
+    }])
+  })
+
+  it('inherits the parent directory for a forked session and forgets deleted sessions', () => {
+    const client = createCapturingClient()
+    sseAggregator.addClient('fork', client.callback, client.writeFrame, ['srv_a|/repo'])
+
+    hub.start()
+    const source = sources.sources[0]!
+    source.message(remoteEvent('session.created', { sessionID: 'ses_parent' }, '/repo'))
+    source.message(remoteEvent('session.forked', { sessionID: 'ses_fork', parentID: 'ses_parent' }))
+    client.frames.length = 0
+
+    source.message(remoteEvent('session.execution.succeeded', { sessionID: 'ses_fork' }))
+    expect(client.frames.map(parseFrame).map(frame => frame.directory)).toEqual(['/repo'])
+
+    source.message(remoteEvent('session.deleted', { sessionID: 'ses_fork' }))
+    client.frames.length = 0
+    source.message(remoteEvent('session.execution.succeeded', { sessionID: 'ses_fork' }))
+
+    expect(client.frames.map(parseFrame)).toEqual([{
+      directory: null,
+      serverId: 'srv_a',
+      payload: {
+        id: 'evt_1',
+        created: 1,
+        type: 'session.execution.succeeded',
+        data: { sessionID: 'ses_fork' },
+      },
+    }])
+  })
+
+  it('falls back to every client holding any key of the server when the directory is unknown', () => {
+    const subscribedA = createCapturingClient()
+    const otherDirectoryA = createCapturingClient()
+    const subscribedB = createCapturingClient()
+    sseAggregator.addClient('any-a', subscribedA.callback, subscribedA.writeFrame, ['srv_a|/repo'])
+    sseAggregator.addClient('other-a', otherDirectoryA.callback, otherDirectoryA.writeFrame, ['srv_a|/elsewhere'])
+    sseAggregator.addClient('any-b', subscribedB.callback, subscribedB.writeFrame, ['srv_b|/repo'])
+
+    hub.start()
+    sources.sources[0]!.message(remoteEvent('server.connected', {}))
+
+    const envelope = {
+      directory: null,
+      serverId: 'srv_a',
+      payload: { id: 'evt_1', created: 1, type: 'server.connected', data: {} },
+    }
+    expect(subscribedA.frames.map(parseFrame)).toEqual([envelope])
+    expect(otherDirectoryA.frames.map(parseFrame)).toEqual([envelope])
+    expect(subscribedB.frames).toHaveLength(0)
+  })
+
+  it('keeps the raw upstream payload in the remote envelope and re-serializes multi-line payloads', () => {
+    const client = createCapturingClient()
+    sseAggregator.addClient('raw-remote', client.callback, client.writeFrame, ['srv_a|/repo'])
+
+    hub.start()
+    const source = sources.sources[0]!
+    const raw = '{"type":"session.idle","id":"evt_raw","created":7,"location":{"directory":"/repo"},"data":{"sessionID":"ses_1","extra":{"b":2,"a":1}}}'
+    source.message(raw)
+
+    expect(client.frames).toEqual([`event: message\ndata: {"directory":"/repo","serverId":"srv_a","payload":${raw}}\n\n`])
+
+    const multiLine = JSON.stringify(JSON.parse(raw), null, 2)
+    source.message(multiLine)
+
+    expect(client.frames[1]!.split('\n').filter(line => line.startsWith('data: '))).toHaveLength(1)
+    expect(parseFrame(client.frames[1]!).payload).toEqual(JSON.parse(raw))
+  })
+
+  it('ignores malformed remote payloads', () => {
+    const client = createCapturingClient()
+    sseAggregator.addClient('malformed-remote', client.callback, client.writeFrame, ['srv_a|/repo'])
+
+    hub.start()
+    const source = sources.sources[0]!
+    source.message('not-json')
+    source.message(JSON.stringify({ id: 'evt', created: 1, data: {} }))
+
+    expect(client.frames).toHaveLength(0)
+  })
+})
+
+describe('RemoteServerEventHub reconnection', () => {
+  let hub: RemoteServerEventHub
+  let fake: FakeRegistry
+  let sources: ReturnType<typeof createSourceFactory>
+
+  beforeEach(() => {
+    sseAggregator.shutdown()
+    sseAggregator.setPendingActionsFetcher(null)
+    sseAggregator.setScheduledSessionsResolver(() => [])
+    fake = createRegistry([SERVER_A])
+    sources = createSourceFactory()
+    hub = new RemoteServerEventHub(fake.registry, sseAggregator, {
+      eventSourceFactory: sources.factory,
+      reconnectDelayMs: 1000,
+      maxReconnectDelayMs: 4000,
+    })
+  })
+
+  afterEach(() => {
+    hub.shutdown()
+    sseAggregator.shutdown()
+    vi.useRealTimers()
+  })
+
+  async function openThenReconnect(): Promise<void> {
+    hub.start()
+    sources.sources[0]!.open()
+    await flushPromises()
+    sources.sources[0]!.fail({ message: 'connection lost' })
+    await vi.advanceTimersByTimeAsync(1000)
+    sources.sources[1]!.open()
+    await flushPromises()
+  }
+
+  it('sends a resync to the subscribers of the server on connect', () => {
+    const clientA = createCapturingClient()
+    const clientB = createCapturingClient()
+    sseAggregator.addClient('resync-a', clientA.callback, clientA.writeFrame, ['srv_a|/repo'])
+    sseAggregator.addClient('resync-b', clientB.callback, clientB.writeFrame, ['srv_b|/repo'])
+
+    hub.start()
+    sources.sources[0]!.open()
+
+    const resyncs = clientA.events.filter(event => event.event === 'resync')
+    expect(resyncs).toHaveLength(1)
+    expect(JSON.parse(resyncs[0]!.data)).toEqual({ timestamp: expect.any(Number), serverId: 'srv_a' })
+    expect(clientB.events.filter(event => event.event === 'resync')).toHaveLength(0)
+  })
+
+  it('closes the failed stream and reconnects with exponential backoff', async () => {
+    vi.useFakeTimers()
+    hub.start()
+    const first = sources.sources[0]!
+    first.open()
+    await flushPromises()
+    first.fail({ message: 'Unauthorized', code: 401 })
+
+    expect(first.closed).toBe(true)
+    expect(hub.getStatuses()).toEqual([
+      { serverId: 'srv_a', connected: false, version: '2.0.15', error: 'Unauthorized' },
+    ])
+
+    await vi.advanceTimersByTimeAsync(999)
+    expect(sources.sources).toHaveLength(1)
+
+    await vi.advanceTimersByTimeAsync(1)
+    expect(sources.sources).toHaveLength(2)
+
+    const second = sources.sources[1]!
+    second.fail({ message: 'Unauthorized', code: 401 })
+
+    await vi.advanceTimersByTimeAsync(1000)
+    expect(sources.sources).toHaveLength(2)
+
+    await vi.advanceTimersByTimeAsync(1000)
+    expect(sources.sources).toHaveLength(3)
+  })
+
+  it('reports the version lazily from the registry without polling', async () => {
+    hub.start()
+    sources.sources[0]!.open()
+    await flushPromises()
+    sources.sources[0]!.open()
+    await flushPromises()
+
+    expect(fake.registry.test).toHaveBeenCalledTimes(1)
+    expect(hub.getStatuses()).toEqual([
+      { serverId: 'srv_a', connected: true, version: '2.0.15', error: null },
+    ])
+  })
+
+  it('probes the version again after a rejected probe', async () => {
+    vi.useFakeTimers()
+    vi.mocked(fake.registry.test)
+      .mockRejectedValueOnce(new Error('no info endpoint'))
+      .mockResolvedValueOnce({ ok: true, version: '2.0.15', versionSupported: true, error: null })
+
+    await openThenReconnect()
+
+    expect(fake.registry.test).toHaveBeenCalledTimes(2)
+    expect(hub.getStatuses()).toEqual([
+      { serverId: 'srv_a', connected: true, version: '2.0.15', error: null },
+    ])
+  })
+
+  it('probes the version again after a probe without a version', async () => {
+    vi.useFakeTimers()
+    vi.mocked(fake.registry.test)
+      .mockResolvedValueOnce({ ok: false, version: null, versionSupported: false, error: 'unreachable' })
+      .mockResolvedValueOnce({ ok: true, version: '2.0.15', versionSupported: true, error: null })
+
+    await openThenReconnect()
+
+    expect(fake.registry.test).toHaveBeenCalledTimes(2)
+    expect(hub.getStatuses()).toEqual([
+      { serverId: 'srv_a', connected: true, version: '2.0.15', error: null },
+    ])
+  })
+
+  it('clears the version and probes again when the server is updated', async () => {
+    hub.start()
+    sources.sources[0]!.open()
+    await flushPromises()
+    expect(hub.getStatuses()[0]?.version).toBe('2.0.15')
+
+    vi.mocked(fake.registry.test).mockResolvedValueOnce({ ok: true, version: '2.1.0', versionSupported: true, error: null })
+    fake.emit({ type: 'upserted', serverId: 'srv_a' })
+
+    expect(hub.getStatuses()[0]?.version).toBeNull()
+
+    sources.sources[1]!.open()
+    await flushPromises()
+
+    expect(fake.registry.test).toHaveBeenCalledTimes(2)
+    expect(hub.getStatuses()[0]?.version).toBe('2.1.0')
+  })
+
+  it('ignores a probe that started before the server was updated', async () => {
+    let resolveFirstProbe: (result: OpenCodeServerTestResult) => void = () => {}
+    vi.mocked(fake.registry.test).mockImplementationOnce(() => new Promise((resolve) => {
+      resolveFirstProbe = resolve
+    }))
+
+    hub.start()
+    sources.sources[0]!.open()
+    await flushPromises()
+    expect(fake.registry.test).toHaveBeenCalledTimes(1)
+
+    vi.mocked(fake.registry.test).mockResolvedValueOnce({ ok: true, version: '2.1.0', versionSupported: true, error: null })
+    fake.emit({ type: 'upserted', serverId: 'srv_a' })
+    sources.sources[1]!.open()
+    await flushPromises()
+
+    resolveFirstProbe({ ok: true, version: '1.0.0', versionSupported: true, error: null })
+    await flushPromises()
+
+    expect(fake.registry.test).toHaveBeenCalledTimes(2)
+    expect(hub.getStatuses()[0]?.version).toBe('2.1.0')
+  })
+
+  it('closes and forgets the stream when the server is disabled', () => {
+    const client = createCapturingClient()
+    sseAggregator.addClient('disable', client.callback, client.writeFrame, ['srv_a|/repo'])
+
+    hub.start()
+    const source = sources.sources[0]!
+    source.open()
+    client.frames.length = 0
+
+    fake.setServer({ ...SERVER_A, enabled: false })
+    fake.emit({ type: 'upserted', serverId: 'srv_a' })
+
+    expect(source.closed).toBe(true)
+    expect(hub.getStatuses()).toEqual([
+      { serverId: 'srv_a', connected: false, version: null, error: null },
+    ])
+
+    source.message(remoteEvent('session.idle', { sessionID: 'ses_1' }, '/repo'))
+    expect(client.frames).toHaveLength(0)
+  })
+
+  it('reconnects with a fresh stream when the server is updated', () => {
+    hub.start()
+    const first = sources.sources[0]!
+    first.open()
+
+    fake.setServer({ ...SERVER_A, baseUrl: 'https://moved.example.com' })
+    fake.emit({ type: 'upserted', serverId: 'srv_a' })
+
+    expect(first.closed).toBe(true)
+    expect(sources.sources).toHaveLength(2)
+    expect(sources.sources[1]!.url).toBe('https://moved.example.com/api/event')
+  })
+
+  it('closes the stream when the server is deleted', () => {
+    hub.start()
+    const source = sources.sources[0]!
+    source.open()
+
+    fake.removeServer('srv_a')
+    fake.emit({ type: 'deleted', serverId: 'srv_a' })
+
+    expect(source.closed).toBe(true)
+    expect(hub.getStatuses()).toEqual([])
+  })
+
+  it('stops reconnecting and clears the replay hook after shutdown', () => {
+    hub.start()
+    const source = sources.sources[0]!
+    source.open()
+    hub.shutdown()
+
+    expect(source.closed).toBe(true)
+
+    const client = createCapturingClient()
+    sseAggregator.addClient('after-shutdown', client.callback, client.writeFrame, ['srv_a|/repo'])
+    expect(fake.api.permission.request.list).not.toHaveBeenCalled()
+  })
+})
+
+describe('RemoteServerEventHub failure handling', () => {
+  let hub: RemoteServerEventHub
+  let fake: FakeRegistry
+  let sources: ReturnType<typeof createSourceFactory>
+
+  beforeEach(() => {
+    sseAggregator.shutdown()
+    sseAggregator.setPendingActionsFetcher(null)
+    sseAggregator.setScheduledSessionsResolver(() => [])
+    fake = createRegistry([SERVER_A])
+    sources = createSourceFactory()
+    hub = new RemoteServerEventHub(fake.registry, sseAggregator, {
+      eventSourceFactory: sources.factory,
+      reconnectDelayMs: 1000,
+      maxReconnectDelayMs: 4000,
+    })
+  })
+
+  afterEach(() => {
+    hub.shutdown()
+    sseAggregator.shutdown()
+    vi.useRealTimers()
+  })
+
+  it('reports a credential-free error for every stream failure shape', async () => {
+    vi.useFakeTimers()
+    hub.start()
+
+    const first = sources.sources[0]!
+    first.fail(new Error('boom'))
+    expect(hub.getStatuses()[0]?.error).toBe('boom')
+
+    await vi.advanceTimersByTimeAsync(1000)
+    sources.sources[1]!.fail('plain failure')
+    expect(hub.getStatuses()[0]?.error).toBe('plain failure')
+
+    await vi.advanceTimersByTimeAsync(2000)
+    sources.sources[2]!.fail({ code: 500 })
+    expect(hub.getStatuses()[0]?.error).toBe('event stream closed (code=500)')
+
+    await vi.advanceTimersByTimeAsync(4000)
+    sources.sources[3]!.fail({})
+    expect(hub.getStatuses()[0]?.error).toBe('event stream disconnected')
+    expect(hub.getStatuses()[0]?.error).not.toContain('Basic')
+    expect(hub.getStatuses()[0]?.error).not.toContain('studio.example.com')
+  })
+
+  it('records a connection failure without credentials and without opening a stream', () => {
+    ;(fake.registry as unknown as { getConnection: (serverId: string) => never }).getConnection = () => {
+      throw new Error('OpenCode server is disabled: srv_a')
+    }
+
+    hub.start()
+
+    expect(sources.sources).toHaveLength(0)
+    expect(hub.getStatuses()).toEqual([
+      { serverId: 'srv_a', connected: false, version: null, error: 'OpenCode server is disabled: srv_a' },
+    ])
+  })
+
+  it('retries with backoff when the event source cannot be created', async () => {
+    vi.useFakeTimers()
+    let attempts = 0
+    const factory: RemoteEventSourceFactory = () => {
+      attempts += 1
+      throw new Error('bad event source')
+    }
+    hub.shutdown()
+    hub = new RemoteServerEventHub(fake.registry, sseAggregator, { eventSourceFactory: factory, reconnectDelayMs: 1000 })
+
+    hub.start()
+    expect(attempts).toBe(1)
+    expect(hub.getStatuses()[0]?.error).toBe('bad event source')
+
+    await vi.advanceTimersByTimeAsync(1000)
+    expect(attempts).toBe(2)
+  })
+
+  it('returns no statuses when the registry cannot be listed', () => {
+    ;(fake.registry as unknown as { list: () => never }).list = () => {
+      throw new Error('db down')
+    }
+
+    hub.start()
+
+    expect(hub.getStatuses()).toEqual([])
+  })
+
+  it('forgets the stream when the server cannot be read on change', () => {
+    hub.start()
+    const source = sources.sources[0]!
+    source.open()
+
+    ;(fake.registry as unknown as { get: (serverId: string) => never }).get = () => {
+      throw new Error('db down')
+    }
+    fake.emit({ type: 'upserted', serverId: 'srv_a' })
+
+    expect(source.closed).toBe(true)
+  })
+
+  it('keeps the version null when the version probe rejects', async () => {
+    vi.mocked(fake.registry.test).mockRejectedValue(new Error('no info endpoint'))
+
+    hub.start()
+    sources.sources[0]!.open()
+    await flushPromises()
+
+    expect(hub.getStatuses()).toEqual([
+      { serverId: 'srv_a', connected: true, version: null, error: null },
+    ])
+  })
+})
+
+describe('RemoteServerEventHub pending action replay', () => {
+  let hub: RemoteServerEventHub
+  let fake: FakeRegistry
+  let sources: ReturnType<typeof createSourceFactory>
+
+  beforeEach(() => {
+    sseAggregator.shutdown()
+    sseAggregator.setPendingActionsFetcher(null)
+    sseAggregator.setScheduledSessionsResolver(() => [])
+    fake = createRegistry([SERVER_A], {
+      permissions: { '/repo': [{ id: 'perm-1', sessionID: 'ses-1', action: 'shell', resources: ['ls'] }] },
+      forms: { '/repo': [{ id: 'form-1', sessionID: 'ses-1', title: 'Continue?', fields: [] }] },
+    })
+    sources = createSourceFactory()
+    hub = new RemoteServerEventHub(fake.registry, sseAggregator, { eventSourceFactory: sources.factory })
+  })
+
+  afterEach(() => {
+    hub.shutdown()
+    sseAggregator.shutdown()
+  })
+
+  it('replays pending remote actions to the subscribing client only', async () => {
+    hub.start()
+    const client = createCapturingClient()
+    const other = createCapturingClient()
+    sseAggregator.addClient('replay-a', client.callback, client.writeFrame, ['srv_a|/repo'])
+    sseAggregator.addClient('replay-b', other.callback, other.writeFrame, ['srv_a|/other'])
+
+    await flushPromises()
+
+    expect(fake.api.permission.request.list).toHaveBeenCalledWith({ location: { directory: '/repo' } })
+    expect(fake.api.form.list).toHaveBeenCalledWith({ location: { directory: '/repo' } })
+
+    const parsed = client.frames.map(parseFrame)
+    expect(parsed.map(frame => frame.serverId)).toEqual(['srv_a', 'srv_a'])
+    expect(parsed.map(frame => frame.directory)).toEqual(['/repo', '/repo'])
+    expect(parsed.map(frame => frame.payload.type)).toEqual(['permission.asked', 'form.created'])
+    expect(parsed[0]?.payload.id).toMatch(/^ocm_replay_remote_/)
+    expect(parsed[1]?.payload.data).toEqual({
+      form: { id: 'form-1', sessionID: 'ses-1', title: 'Continue?', fields: [] },
+    })
+    expect(other.frames).toHaveLength(0)
+  })
+
+  it('does not use the local pending action fetcher for remote keys', async () => {
+    const localApi = makeApi({ permissions: { '/repo': [{ id: 'local-perm' }] } })
+    sseAggregator.setPendingActionsFetcher({ api: localApi })
+
+    hub.start()
+    const client = createCapturingClient()
+    sseAggregator.addClient('mixed', client.callback, client.writeFrame, ['/repo', 'srv_a|/repo'])
+
+    await flushPromises()
+
+    expect(localApi.permission.request.list).toHaveBeenCalledTimes(1)
+    expect(localApi.permission.request.list).toHaveBeenCalledWith({ location: { directory: '/repo' } })
+    expect(fake.api.permission.request.list).toHaveBeenCalledTimes(1)
+    expect(fake.api.permission.request.list).toHaveBeenCalledWith({ location: { directory: '/repo' } })
+  })
+
+  it('replays remote actions when a client subscribes later', async () => {
+    hub.start()
+    const client = createCapturingClient()
+    sseAggregator.addClient('late', client.callback, client.writeFrame, [])
+
+    sseAggregator.addDirectories('late', ['srv_a|/repo'])
+    await flushPromises()
+
+    expect(client.frames.map(parseFrame).map(frame => frame.payload.type)).toEqual(['permission.asked', 'form.created'])
+  })
+
+  it('skips the replay when the client unsubscribed before it resolved', async () => {
+    let resolvePermissions: (value: { location: { directory: string }; data: unknown[] }) => void = () => {}
+    const list = fake.api.permission.request.list as unknown as (input: { location?: { directory?: string } }) => Promise<unknown>
+    vi.mocked(list).mockImplementation(() => new Promise((resolve) => {
+      resolvePermissions = resolve as (value: { location: { directory: string }; data: unknown[] }) => void
+    }))
+    vi.mocked(fake.api.form.list).mockResolvedValue({ location: { directory: '/repo' }, data: [] })
+
+    hub.start()
+    const client = createCapturingClient()
+    sseAggregator.addClient('unsubscribed', client.callback, client.writeFrame, ['srv_a|/repo'])
+    sseAggregator.removeDirectories('unsubscribed', ['srv_a|/repo'])
+
+    resolvePermissions({ location: { directory: '/repo' }, data: [{ id: 'late', sessionID: 'ses-1' }] })
+    await flushPromises()
+
+    expect(client.frames).toHaveLength(0)
+  })
+})
+
+describe('RemoteServerEventHub session status replay', () => {
+  let hub: RemoteServerEventHub
+  let fake: FakeRegistry
+  let sources: ReturnType<typeof createSourceFactory>
+
+  beforeEach(() => {
+    sseAggregator.shutdown()
+    sseAggregator.setPendingActionsFetcher(null)
+    sseAggregator.setScheduledSessionsResolver(() => [])
+    sources = createSourceFactory()
+  })
+
+  afterEach(() => {
+    hub.shutdown()
+    sseAggregator.shutdown()
+  })
+
+  function createHub(fixture: ApiFixture = {}): void {
+    fake = createRegistry([SERVER_A], fixture)
+    hub = new RemoteServerEventHub(fake.registry, sseAggregator, { eventSourceFactory: sources.factory })
+  }
+
+  function statusFrames(client: CapturedClient) {
+    return client.frames.map(parseFrame).filter(frame => frame.payload.type === 'session.status')
+  }
+
+  async function trackSessionThenReconnect(sessionID: string, directory: string): Promise<void> {
+    hub.start()
+    const first = sources.sources[0]!
+    first.open()
+    await flushPromises()
+    first.message(remoteEvent('session.created', { sessionID }, directory))
+    fake.emit({ type: 'upserted', serverId: 'srv_a' })
+    await flushPromises()
+  }
+
+  it('replays idle for a tracked session that is no longer active', async () => {
+    createHub()
+    await trackSessionThenReconnect('ses_1', '/repo')
+    const client = createCapturingClient()
+    sseAggregator.addClient('status-idle', client.callback, client.writeFrame, ['srv_a|/repo'])
+
+    sources.sources[1]!.open()
+    await flushPromises()
+
+    const statuses = statusFrames(client)
+    expect(statuses).toHaveLength(1)
+    expect(statuses[0]?.serverId).toBe('srv_a')
+    expect(statuses[0]?.directory).toBe('/repo')
+    expect(statuses[0]?.payload.id).toMatch(/^ocm_replay_remote_/)
+    expect(statuses[0]?.payload.data).toEqual({ sessionID: 'ses_1', status: { type: 'idle' } })
+  })
+
+  it('replays busy for active sessions, using a null directory when the session is untracked', async () => {
+    createHub({ active: { ses_1: { type: 'running' }, ses_2: { type: 'running' } } })
+    await trackSessionThenReconnect('ses_1', '/repo')
+    const client = createCapturingClient()
+    sseAggregator.addClient('status-busy', client.callback, client.writeFrame, ['srv_a|/repo'])
+
+    sources.sources[1]!.open()
+    await flushPromises()
+
+    const statuses = statusFrames(client)
+    expect(statuses.map(frame => frame.directory)).toEqual(['/repo', null])
+    expect(statuses.map(frame => frame.payload.data)).toEqual([
+      { sessionID: 'ses_1', status: { type: 'busy' } },
+      { sessionID: 'ses_2', status: { type: 'busy' } },
+    ])
+  })
+
+  it('does not replay or throw when the active session lookup fails', async () => {
+    createHub()
+    vi.mocked(fake.api.session.active).mockRejectedValue(new Error('sessions unavailable'))
+    await trackSessionThenReconnect('ses_1', '/repo')
+    const client = createCapturingClient()
+    sseAggregator.addClient('status-failure', client.callback, client.writeFrame, ['srv_a|/repo'])
+
+    sources.sources[1]!.open()
+    await flushPromises()
+
+    expect(fake.api.session.active).toHaveBeenCalledTimes(2)
+    expect(statusFrames(client)).toHaveLength(0)
+  })
+
+  it('skips the replay when the stream disconnects before the active sessions resolve', async () => {
+    createHub()
+    const client = createCapturingClient()
+    sseAggregator.addClient('status-stale', client.callback, client.writeFrame, ['srv_a|/repo'])
+
+    hub.start()
+    const first = sources.sources[0]!
+    first.open()
+    await flushPromises()
+    first.message(remoteEvent('session.created', { sessionID: 'ses_1' }, '/repo'))
+
+    let resolveActive: (value: Record<string, { type: 'running' }>) => void = () => {}
+    vi.mocked(fake.api.session.active).mockReturnValueOnce(new Promise<Record<string, { type: 'running' }>>((resolve) => {
+      resolveActive = resolve
+    }) as never)
+
+    fake.emit({ type: 'upserted', serverId: 'srv_a' })
+    const second = sources.sources[1]!
+    second.open()
+    await flushPromises()
+    expect(fake.api.session.active).toHaveBeenCalledTimes(2)
+
+    second.fail({ message: 'connection lost' })
+    resolveActive({})
+    await flushPromises()
+
+    expect(statusFrames(client)).toHaveLength(0)
+  })
+})
diff --git a/backend/test/services/sse-aggregator-remote.test.ts b/backend/test/services/sse-aggregator-remote.test.ts
new file mode 100644
index 000000000..66cc60f5f
--- /dev/null
+++ b/backend/test/services/sse-aggregator-remote.test.ts
@@ -0,0 +1,217 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('@opencode-manager/shared/config/env', () => ({
+  ENV: {
+    OPENCODE: { PORT: 5551, HOST: '127.0.0.1' },
+  },
+}))
+
+vi.mock('../../src/utils/logger', () => ({
+  logger: {
+    info: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+  },
+}))
+
+import type { OpenCodeApi } from '@opencode-manager/shared/opencode'
+import { sseAggregator, type PendingActionsFetcher } from '../../src/services/sse-aggregator'
+
+interface CapturedClient {
+  events: Array<{ event: string; data: string }>
+  frames: string[]
+  callback: (event: string, data: string) => void
+  writeFrame: (frame: Uint8Array) => void
+}
+
+function createCapturingClient(): CapturedClient {
+  const events: Array<{ event: string; data: string }> = []
+  const frames: string[] = []
+  const decoder = new TextDecoder()
+  return {
+    events,
+    frames,
+    callback: (event, data) => { events.push({ event, data }) },
+    writeFrame: (frame) => { frames.push(decoder.decode(frame)) },
+  }
+}
+
+function parseFrame(frame: string): { directory: string | null; serverId?: string; payload: { type: string } } {
+  return JSON.parse(frame.replace(/^event: message\ndata: /, '').trim())
+}
+
+function makeFetcher(): PendingActionsFetcher {
+  const api = {
+    permission: {
+      request: {
+        list: vi.fn(async (input?: { location?: { directory?: string } }) => ({
+          location: { directory: input?.location?.directory ?? '' },
+          data: [{ id: 'perm-1', sessionID: 'ses-1' }],
+        })),
+      },
+    },
+    form: {
+      list: vi.fn(async (input?: { location?: { directory?: string } }) => ({
+        location: { directory: input?.location?.directory ?? '' },
+        data: [],
+      })),
+    },
+  } as unknown as OpenCodeApi
+  return { api }
+}
+
+async function flushReplay(): Promise<void> {
+  for (let i = 0; i < 10; i++) {
+    await Promise.resolve()
+  }
+}
+
+const PAYLOAD = '{"id":"evt_1","created":1,"type":"session.idle","location":{"directory":"/repo"},"data":{"sessionID":"ses_1"}}'
+
+describe('SSEAggregator remote envelope delivery', () => {
+  beforeEach(() => {
+    sseAggregator.shutdown()
+    sseAggregator.setPendingActionsFetcher(null)
+    sseAggregator.setScheduledSessionsResolver(() => [])
+  })
+
+  it('delivers a remote envelope only to clients subscribed to that server and directory', () => {
+    const subscribed = createCapturingClient()
+    const otherDirectory = createCapturingClient()
+    const local = createCapturingClient()
+    sseAggregator.addClient('remote-key', subscribed.callback, subscribed.writeFrame, ['srv_a|/repo'])
+    sseAggregator.addClient('other-dir', otherDirectory.callback, otherDirectory.writeFrame, ['srv_a|/other'])
+    sseAggregator.addClient('local-dir', local.callback, local.writeFrame, ['/repo'])
+
+    sseAggregator.deliverRemoteEnvelope('srv_a', '/repo', PAYLOAD)
+
+    expect(subscribed.frames).toEqual([
+      `event: message\ndata: {"directory":"/repo","serverId":"srv_a","payload":${PAYLOAD}}\n\n`,
+    ])
+    expect(otherDirectory.frames).toHaveLength(0)
+    expect(local.frames).toHaveLength(0)
+  })
+
+  it('broadcasts a directory-less remote envelope to every client holding any key of that server', () => {
+    const first = createCapturingClient()
+    const second = createCapturingClient()
+    const otherServer = createCapturingClient()
+    const local = createCapturingClient()
+    sseAggregator.addClient('any-a', first.callback, first.writeFrame, ['srv_a|/repo'])
+    sseAggregator.addClient('any-b', second.callback, second.writeFrame, ['srv_a|/elsewhere'])
+    sseAggregator.addClient('any-c', otherServer.callback, otherServer.writeFrame, ['srv_b|/repo'])
+    sseAggregator.addClient('any-d', local.callback, local.writeFrame, ['/repo'])
+
+    sseAggregator.deliverRemoteEnvelope('srv_a', null, PAYLOAD)
+
+    const expected = { directory: null, serverId: 'srv_a', payload: JSON.parse(PAYLOAD) }
+    expect(first.frames.map(parseFrame)).toEqual([expected])
+    expect(second.frames.map(parseFrame)).toEqual([expected])
+    expect(otherServer.frames).toHaveLength(0)
+    expect(local.frames).toHaveLength(0)
+  })
+
+  it('skips a targeted remote envelope once the client unsubscribed', () => {
+    const client = createCapturingClient()
+    sseAggregator.addClient('targeted', client.callback, client.writeFrame, ['srv_a|/repo'])
+    sseAggregator.removeDirectories('targeted', ['srv_a|/repo'])
+
+    sseAggregator.deliverRemoteEnvelopeToClient('targeted', 'srv_a', '/repo', PAYLOAD)
+
+    expect(client.frames).toHaveLength(0)
+  })
+
+  it('delivers a targeted remote envelope to a subscribed client', () => {
+    const client = createCapturingClient()
+    sseAggregator.addClient('targeted-ok', client.callback, client.writeFrame, ['srv_a|/repo'])
+
+    sseAggregator.deliverRemoteEnvelopeToClient('targeted-ok', 'srv_a', '/repo', PAYLOAD)
+
+    expect(client.frames.map(parseFrame)).toEqual([
+      { directory: '/repo', serverId: 'srv_a', payload: JSON.parse(PAYLOAD) },
+    ])
+  })
+
+  it('sends a resync only to the subscribers of that server', () => {
+    const subscribed = createCapturingClient()
+    const otherServer = createCapturingClient()
+    const local = createCapturingClient()
+    sseAggregator.addClient('resync-a', subscribed.callback, subscribed.writeFrame, ['srv_a|/repo'])
+    sseAggregator.addClient('resync-b', otherServer.callback, otherServer.writeFrame, ['srv_b|/repo'])
+    sseAggregator.addClient('resync-c', local.callback, local.writeFrame, ['/repo'])
+
+    sseAggregator.sendRemoteResync('srv_a')
+
+    expect(subscribed.events).toHaveLength(1)
+    expect(subscribed.events[0]!.event).toBe('resync')
+    expect(JSON.parse(subscribed.events[0]!.data)).toEqual({ timestamp: expect.any(Number), serverId: 'srv_a' })
+    expect(otherServer.events).toHaveLength(0)
+    expect(local.events).toHaveLength(0)
+    expect(subscribed.frames).toHaveLength(0)
+  })
+
+  it('keeps the local envelope free of a serverId', () => {
+    const client = createCapturingClient()
+    sseAggregator.addClient('local-envelope', client.callback, client.writeFrame, ['/repo'])
+
+    ;(sseAggregator as unknown as { handleUpstreamMessage(data: string): void }).handleUpstreamMessage(PAYLOAD)
+
+    expect(client.frames).toEqual([`event: message\ndata: {"directory":"/repo","payload":${PAYLOAD}}\n\n`])
+    expect(client.frames[0]).not.toContain('serverId')
+    expect(parseFrame(client.frames[0]!).serverId).toBeUndefined()
+  })
+
+  it('routes remote subscriptions to the remote replay hook instead of the local fetcher', async () => {
+    const fetcher = makeFetcher()
+    sseAggregator.setPendingActionsFetcher(fetcher)
+    const remoteReplay = vi.fn(async () => {})
+
+    sseAggregator.addClient('mixed', () => {}, () => {}, ['/repo', 'srv_a|/repo'])
+    sseAggregator.setRemoteReplayHandler(remoteReplay)
+    sseAggregator.addDirectories('mixed', ['srv_a|/new'])
+
+    await flushReplay()
+
+    expect(remoteReplay).toHaveBeenCalledTimes(1)
+    expect(remoteReplay).toHaveBeenCalledWith('mixed', 'srv_a', '/new')
+    expect(fetcher.api.permission.request.list).toHaveBeenCalledTimes(1)
+    expect(fetcher.api.permission.request.list).toHaveBeenCalledWith({ location: { directory: '/repo' } })
+  })
+
+  it('does not replay remote keys through the local fetcher on connect', async () => {
+    const fetcher = makeFetcher()
+    sseAggregator.setPendingActionsFetcher(fetcher)
+    const remoteReplay = vi.fn()
+    sseAggregator.setRemoteReplayHandler(remoteReplay)
+
+    sseAggregator.addClient('remote-only', () => {}, () => {}, ['srv_a|/repo'])
+    await flushReplay()
+
+    expect(fetcher.api.permission.request.list).not.toHaveBeenCalled()
+    expect(fetcher.api.form.list).not.toHaveBeenCalled()
+    expect(remoteReplay).toHaveBeenCalledWith('remote-only', 'srv_a', '/repo')
+  })
+
+  it('isolates a failing remote replay hook', async () => {
+    const healthy = vi.fn()
+    sseAggregator.setRemoteReplayHandler(() => { throw new Error('boom') })
+    sseAggregator.addClient('failing', () => {}, () => {}, ['srv_a|/repo'])
+    await flushReplay()
+
+    sseAggregator.setRemoteReplayHandler(healthy)
+    sseAggregator.addDirectories('failing', ['srv_a|/other'])
+    await flushReplay()
+
+    expect(healthy).toHaveBeenCalledWith('failing', 'srv_a', '/other')
+  })
+
+  it('stops broadcasting remote envelopes after a client is removed', () => {
+    const client = createCapturingClient()
+    sseAggregator.addClient('removed', client.callback, client.writeFrame, ['srv_a|/repo'])
+    sseAggregator.removeClient('removed')
+
+    sseAggregator.deliverRemoteEnvelope('srv_a', null, PAYLOAD)
+
+    expect(client.frames).toHaveLength(0)
+  })
+})
diff --git a/backend/test/services/sse-aggregator.test.ts b/backend/test/services/sse-aggregator.test.ts
index 378f641e4..a912e3ffb 100644
--- a/backend/test/services/sse-aggregator.test.ts
+++ b/backend/test/services/sse-aggregator.test.ts
@@ -571,7 +571,7 @@ describe('SSEAggregator upstream resynchronization signal', () => {
 
     const resyncs = client.events.filter(event => event.event === 'resync')
     expect(resyncs).toHaveLength(2)
-    expect(JSON.parse(resyncs[0]!.data)).toMatchObject({ timestamp: expect.any(Number) })
+    expect(JSON.parse(resyncs[0]!.data)).toEqual({ timestamp: expect.any(Number) })
     expect(client.frames).toHaveLength(0)
   })
 
diff --git a/frontend/package.json b/frontend/package.json
index 82e3223eb..8dad5385b 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -38,6 +38,7 @@
     "cronstrue": "^3.13.0",
     "date-fns": "^4.1.0",
     "diff": "^8.0.2",
+    "jsqr": "^1.4.0",
     "lucide-react": "^0.546.0",
     "mermaid": "^11.12.2",
     "react": "^19.1.1",
diff --git a/frontend/src/App.permission-dialog.test.tsx b/frontend/src/App.permission-dialog.test.tsx
new file mode 100644
index 000000000..df89ba600
--- /dev/null
+++ b/frontend/src/App.permission-dialog.test.tsx
@@ -0,0 +1,116 @@
+import { render, screen, fireEvent } from '@testing-library/react'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { PermissionRequest } from '@opencode-manager/shared/opencode'
+
+const mocks = vi.hoisted(() => ({
+  usePermissions: vi.fn(),
+  getRepoIdForSession: vi.fn(),
+  useSession: vi.fn(),
+  navigateToCurrent: vi.fn(),
+  PermissionRequestDialog: vi.fn(),
+}))
+
+vi.mock('@/contexts/EventContext', () => ({
+  usePermissions: mocks.usePermissions,
+  useEventContext: () => ({ getRepoIdForSession: mocks.getRepoIdForSession }),
+}))
+
+vi.mock('@/hooks/useOpenCode', () => ({ useSession: mocks.useSession }))
+
+vi.mock('@/components/session/PermissionRequestDialog', () => ({
+  PermissionRequestDialog: mocks.PermissionRequestDialog,
+}))
+
+vi.mock('react-router-dom', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('react-router-dom')>()
+  return { ...actual, createBrowserRouter: vi.fn(() => ({ routes: [] })) }
+})
+
+import { PermissionDialogWrapper } from './App'
+
+type PendingPermission = PermissionRequest & { serverId: string }
+
+const remotePermission: PendingPermission = {
+  id: 'permission-1',
+  sessionID: 'ses_remote',
+  action: 'shell',
+  resources: ['echo hello'],
+  metadata: {},
+  serverId: 'srv_kitchen',
+}
+
+const localPermission: PendingPermission = {
+  id: 'permission-2',
+  sessionID: 'ses_local',
+  action: 'shell',
+  resources: ['echo hello'],
+  metadata: {},
+  serverId: 'local',
+}
+
+interface DialogProps {
+  permission: PermissionRequest | null
+  onOpenSession?: () => void
+}
+
+function renderWrapper(permission: PendingPermission) {
+  mocks.usePermissions.mockReturnValue({
+    current: permission,
+    pendingCount: 1,
+    respond: vi.fn(),
+    showDialog: true,
+    setShowDialog: vi.fn(),
+    navigateToCurrent: mocks.navigateToCurrent,
+    viewedSessionId: null,
+    currentDirectory: '/srv/app',
+    currentIsFromDifferentSession: false,
+  })
+
+  render(<PermissionDialogWrapper />)
+
+  return mocks.PermissionRequestDialog.mock.calls.at(-1)?.[0] as DialogProps
+}
+
+describe('PermissionDialogWrapper', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mocks.useSession.mockReturnValue({ data: undefined })
+    mocks.PermissionRequestDialog.mockReturnValue(<div data-testid="permission-dialog" />)
+  })
+
+  it('offers the session for a linked-server permission without a Manager repo lookup', () => {
+    mocks.getRepoIdForSession.mockReturnValue(null)
+
+    const props = renderWrapper(remotePermission)
+
+    expect(props.permission).toEqual(remotePermission)
+    expect(props.onOpenSession).toBe(mocks.navigateToCurrent)
+    expect(mocks.getRepoIdForSession).not.toHaveBeenCalled()
+    expect(mocks.useSession).toHaveBeenCalledWith(undefined, '/srv/app')
+  })
+
+  it('offers the session for a local permission resolved through its Manager repo', () => {
+    mocks.getRepoIdForSession.mockReturnValue(12)
+
+    const props = renderWrapper(localPermission)
+
+    expect(props.onOpenSession).toBe(mocks.navigateToCurrent)
+    expect(mocks.getRepoIdForSession).toHaveBeenCalledWith('ses_local')
+    expect(mocks.useSession).toHaveBeenCalledWith('ses_local', '/srv/app')
+  })
+
+  it('hides the session action for a local permission without a Manager repo', () => {
+    mocks.getRepoIdForSession.mockReturnValue(null)
+
+    const props = renderWrapper(localPermission)
+
+    expect(props.onOpenSession).toBeUndefined()
+  })
+
+  it('renders the dialog host', () => {
+    renderWrapper(remotePermission)
+
+    expect(screen.getByTestId('permission-dialog')).toBeInTheDocument()
+    fireEvent.click(screen.getByTestId('permission-dialog'))
+  })
+})
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index 8d1613fdc..f020528b6 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -1,10 +1,12 @@
 
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
-import { createBrowserRouter, RouterProvider, Outlet, useNavigate, useLocation } from 'react-router-dom'
-import { useEffect, useRef, useCallback } from 'react'
+import { createBrowserRouter, RouterProvider, Outlet, useNavigate, useLocation, useParams, Navigate } from 'react-router-dom'
+import { useEffect, useRef, useCallback, type ReactNode } from 'react'
+import { LOCAL_OPENCODE_SERVER_ID } from '@opencode-manager/shared/schemas'
 import { Toaster } from 'sonner'
 import { Repos } from './pages/Repos'
 import { RepoDetail } from './pages/RepoDetail'
+import { RemoteServer } from './pages/RemoteServer'
 import { SessionDetail } from './pages/SessionDetail'
 import { Schedules } from './pages/Schedules'
 import { GlobalSchedules } from './pages/GlobalSchedules'
@@ -26,6 +28,7 @@ import { ThemeProvider, useThemeMode } from './contexts/ThemeContext'
 import { AuthProvider } from './contexts/AuthContext'
 import { KeyboardShortcutsProvider } from './contexts/KeyboardShortcutsContext'
 import { EventProvider, usePermissions, useEventContext } from '@/contexts/EventContext'
+import { OpenCodeServerProvider, isLocalOpenCodeServer } from '@/contexts/OpenCodeServerContext'
 import { RepoWorktreesProvider } from '@/contexts/RepoWorktreesContext'
 import { SwipeNavigationProvider, useSwipeNavigation } from '@/contexts/SwipeNavigationContext'
 import { PermissionRequestDialog } from './components/session/PermissionRequestDialog'
@@ -98,7 +101,7 @@ function HealthMonitor() {
   )
 }
 
-function PermissionDialogWrapper() {
+export function PermissionDialogWrapper() {
   const {
     current: currentPermission,
     pendingCount,
@@ -111,10 +114,14 @@ function PermissionDialogWrapper() {
     currentIsFromDifferentSession,
   } = usePermissions()
   const { getRepoIdForSession } = useEventContext()
-  const { data: session } = useSession(currentPermission?.sessionID, currentDirectory ?? undefined)
+  const isRemotePermission = currentPermission !== null && !isLocalOpenCodeServer(currentPermission.serverId)
+  const { data: session } = useSession(
+    isRemotePermission ? undefined : currentPermission?.sessionID,
+    currentDirectory ?? undefined,
+  )
 
   const canOpenCurrentSession = currentPermission !== null
-    && getRepoIdForSession(currentPermission.sessionID) !== null
+    && (isRemotePermission || getRepoIdForSession(currentPermission.sessionID) !== null)
     && (currentIsFromDifferentSession || viewedSessionId === null)
 
   return (
@@ -137,6 +144,16 @@ function GlobalShortcuts() {
   return null
 }
 
+function ServerScope({ children }: { children: ReactNode }) {
+  const { serverId } = useParams<{ serverId: string }>()
+
+  if (!serverId || serverId === LOCAL_OPENCODE_SERVER_ID) {
+    return <Navigate to="/" replace />
+  }
+
+  return <OpenCodeServerProvider serverId={serverId}>{children}</OpenCodeServerProvider>
+}
+
 function AppShell() {
   const navigate = useNavigate()
   const location = useLocation()
@@ -292,6 +309,24 @@ const router = createBrowserRouter([
         element: <GlobalSchedules />,
         loader: protectedLoader,
       },
+      {
+        path: '/servers/:serverId',
+        element: (
+          <ServerScope>
+            <RemoteServer />
+          </ServerScope>
+        ),
+        loader: protectedLoader,
+      },
+      {
+        path: '/servers/:serverId/sessions/:sessionId',
+        element: (
+          <ServerScope>
+            <SessionDetail />
+          </ServerScope>
+        ),
+        loader: protectedLoader,
+      },
     ],
   },
 ])
diff --git a/frontend/src/api/mcp.ts b/frontend/src/api/mcp.ts
index 318475e6f..10bd1a643 100644
--- a/frontend/src/api/mcp.ts
+++ b/frontend/src/api/mcp.ts
@@ -22,27 +22,33 @@ type McpOAuthFlowStatus =
   | { status: 'unknown' }
 
 export const mcpApi = {
-  async getStatus(directory?: string): Promise<McpStatusMap> {
-    const { data } = await callOpenCode((api) => api.mcp.list(openCodeLocation(directory)))
+  async getStatus(directory?: string, serverId?: string): Promise<McpStatusMap> {
+    const { data } = await callOpenCode((api) => api.mcp.list(openCodeLocation(directory)), serverId)
     return mcpStatusByName(data)
   },
 
-  async removeServer(name: string): Promise<void> {
+  async removeServer(name: string, serverId?: string): Promise<void> {
     await callOpenCode(async (api) => {
       try {
         await api.mcp.remove({ server: name })
       } catch (error) {
         if (!isMcpServerNotFoundError(error)) throw error
       }
-    })
+    }, serverId)
   },
 
-  async connect(name: string, directory?: string): Promise<void> {
-    await callOpenCode((api) => api.mcp.connect({ server: name, ...openCodeLocation(directory) }))
+  async connect(name: string, directory?: string, serverId?: string): Promise<void> {
+    await callOpenCode(
+      (api) => api.mcp.connect({ server: name, ...openCodeLocation(directory) }),
+      serverId,
+    )
   },
 
-  async disconnect(name: string, directory?: string): Promise<void> {
-    await callOpenCode((api) => api.mcp.disconnect({ server: name, ...openCodeLocation(directory) }))
+  async disconnect(name: string, directory?: string, serverId?: string): Promise<void> {
+    await callOpenCode(
+      (api) => api.mcp.disconnect({ server: name, ...openCodeLocation(directory) }),
+      serverId,
+    )
   },
 
   async startAuth(name: string, directory?: string): Promise<McpAuthStartResponse> {
diff --git a/frontend/src/api/opencode.ts b/frontend/src/api/opencode.ts
index fd5220b58..84a10121d 100644
--- a/frontend/src/api/opencode.ts
+++ b/frontend/src/api/opencode.ts
@@ -35,6 +35,8 @@ export type ShellOutputChunk = Awaited<ReturnType<OpenCodeApi['shell']['output']
 
 export type OpenCodeLocationInfo = Awaited<ReturnType<OpenCodeApi['location']['get']>>
 
+export type OpenCodeProject = Awaited<ReturnType<OpenCodeApi['project']['list']>>[number]
+
 export interface SessionPage {
   items: SessionInfo[]
   nextCursor?: string
@@ -97,7 +99,7 @@ function buildPromptFields(input: PromptFields) {
   }
 }
 
-export async function listSessionPage(input: SessionPageInput): Promise<SessionPage> {
+export async function listSessionPage(input: SessionPageInput, serverId?: string): Promise<SessionPage> {
   const { data, cursor } = await callOpenCode((api) =>
     api.session.list({
       ...(input.directory === undefined ? {} : { directory: input.directory }),
@@ -109,104 +111,130 @@ export async function listSessionPage(input: SessionPageInput): Promise<SessionP
       search: input.search,
       cursor: input.cursor,
     }),
+    serverId,
   )
   return { items: data, nextCursor: cursor.next ?? undefined }
 }
 
-export async function getOpenCodeLocation(directory: string): Promise<OpenCodeLocationInfo> {
-  return callOpenCode((api) => api.location.get(openCodeLocation(directory)))
+export async function getOpenCodeLocation(directory: string, serverId?: string): Promise<OpenCodeLocationInfo> {
+  return callOpenCode((api) => api.location.get(openCodeLocation(directory)), serverId)
+}
+
+export async function listProjects(serverId?: string): Promise<OpenCodeProject[]> {
+  return callOpenCode((api) => api.project.list(), serverId)
 }
 
-export async function getSession(sessionID: string): Promise<SessionInfo> {
-  return callOpenCode((api) => api.session.get({ sessionID }))
+export async function getSession(sessionID: string, serverId?: string): Promise<SessionInfo> {
+  return callOpenCode((api) => api.session.get({ sessionID }), serverId)
 }
 
-export async function createSession(input: CreateSessionInput): Promise<SessionInfo> {
+export async function createSession(input: CreateSessionInput, serverId?: string): Promise<SessionInfo> {
   const model = input.model ? parseOpenCodeModelRef(input.model) : undefined
-  return callOpenCode((api) =>
-    api.session.create({
-      ...(input.title !== undefined ? { title: input.title } : {}),
-      ...(input.agent !== undefined ? { agent: input.agent } : {}),
-      ...(model ? { model } : {}),
-      location: { directory: input.directory },
-    }),
+  return callOpenCode(
+    (api) =>
+      api.session.create({
+        ...(input.title !== undefined ? { title: input.title } : {}),
+        ...(input.agent !== undefined ? { agent: input.agent } : {}),
+        ...(model ? { model } : {}),
+        location: { directory: input.directory },
+      }),
+    serverId,
   )
 }
 
-export async function deleteSession(sessionID: string): Promise<void> {
-  await callOpenCode((api) => api.session.remove({ sessionID }))
+export async function deleteSession(sessionID: string, serverId?: string): Promise<void> {
+  await callOpenCode((api) => api.session.remove({ sessionID }), serverId)
 }
 
-export async function renameSession(sessionID: string, title: string): Promise<void> {
-  await callOpenCode((api) => api.session.update({ sessionID, title }))
+export async function renameSession(sessionID: string, title: string, serverId?: string): Promise<void> {
+  await callOpenCode((api) => api.session.update({ sessionID, title }), serverId)
 }
 
-export async function forkSession(sessionID: string, before?: string): Promise<SessionInfo> {
-  return callOpenCode((api) =>
-    api.session.fork({
-      sessionID,
-      ...(before ? { before } : {}),
-    }),
+export async function forkSession(sessionID: string, before?: string, serverId?: string): Promise<SessionInfo> {
+  return callOpenCode(
+    (api) =>
+      api.session.fork({
+        sessionID,
+        ...(before ? { before } : {}),
+      }),
+    serverId,
   )
 }
 
-export async function addSessionContext(sessionID: string, text: string): Promise<void> {
-  await callOpenCode((api) => api.session.synthetic({ sessionID, text, resume: false }))
+export async function addSessionContext(sessionID: string, text: string, serverId?: string): Promise<void> {
+  await callOpenCode((api) => api.session.synthetic({ sessionID, text, resume: false }), serverId)
 }
 
 async function createSessionThen(
   input: CreateSessionInput,
   step: (session: SessionInfo) => Promise<unknown>,
+  serverId?: string,
 ): Promise<SessionInfo> {
-  const session = await createSession(input)
+  const session = await createSession(input, serverId)
   try {
     await step(session)
   } catch (error) {
-    await deleteSession(session.id).catch(() => undefined)
+    await deleteSession(session.id, serverId).catch(() => undefined)
     throw error
   }
   return session
 }
 
-export async function createSessionWithContext(input: CreateSessionInput, context: string): Promise<SessionInfo> {
-  return createSessionThen(input, (session) => addSessionContext(session.id, context))
+export async function createSessionWithContext(
+  input: CreateSessionInput,
+  context: string,
+  serverId?: string,
+): Promise<SessionInfo> {
+  return createSessionThen(input, (session) => addSessionContext(session.id, context, serverId), serverId)
 }
 
-export async function createSessionWithPrompt(input: CreateSessionInput, text: string): Promise<SessionInfo> {
-  return createSessionThen(input, (session) => sendPrompt({ sessionID: session.id, text }))
+export async function createSessionWithPrompt(
+  input: CreateSessionInput,
+  text: string,
+  serverId?: string,
+): Promise<SessionInfo> {
+  return createSessionThen(
+    input,
+    (session) => sendPrompt({ sessionID: session.id, text }, serverId),
+    serverId,
+  )
 }
 
-export async function switchSessionModel(sessionID: string, model: ModelRef): Promise<void> {
-  await callOpenCode((api) => api.session.switchModel({ sessionID, model }))
+export async function switchSessionModel(sessionID: string, model: ModelRef, serverId?: string): Promise<void> {
+  await callOpenCode((api) => api.session.switchModel({ sessionID, model }), serverId)
 }
 
-export async function switchSessionAgent(sessionID: string, agent: string): Promise<void> {
-  await callOpenCode((api) => api.session.switchAgent({ sessionID, agent }))
+export async function switchSessionAgent(sessionID: string, agent: string, serverId?: string): Promise<void> {
+  await callOpenCode((api) => api.session.switchAgent({ sessionID, agent }), serverId)
 }
 
 /** Sends a session prompt with client metadata derived from the current viewport. */
-export async function sendPrompt(input: SendPromptInput): Promise<SessionInboxUser> {
-  return callOpenCode((api) =>
-    api.session.prompt({
-      sessionID: input.sessionID,
-      ...buildPromptFields(input),
-      metadata: { [MANAGER_PROMPT_CLIENT_METADATA_KEY]: isMobileViewport() ? 'mobile' : 'desktop' },
-    }),
+export async function sendPrompt(input: SendPromptInput, serverId?: string): Promise<SessionInboxUser> {
+  return callOpenCode(
+    (api) =>
+      api.session.prompt({
+        sessionID: input.sessionID,
+        ...buildPromptFields(input),
+        metadata: { [MANAGER_PROMPT_CLIENT_METADATA_KEY]: isMobileViewport() ? 'mobile' : 'desktop' },
+      }),
+    serverId,
   )
 }
 
-export async function runCommand(input: RunCommandInput): Promise<void> {
-  await callOpenCode((api) =>
-    api.session.command({
-      sessionID: input.sessionID,
-      name: input.name,
-      ...buildPromptFields(input),
-    }),
+export async function runCommand(input: RunCommandInput, serverId?: string): Promise<void> {
+  await callOpenCode(
+    (api) =>
+      api.session.command({
+        sessionID: input.sessionID,
+        name: input.name,
+        ...buildPromptFields(input),
+      }),
+    serverId,
   )
 }
 
-export async function runShell(sessionID: string, command: string): Promise<void> {
-  await callOpenCode((api) => api.session.shell({ sessionID, command }))
+export async function runShell(sessionID: string, command: string, serverId?: string): Promise<void> {
+  await callOpenCode((api) => api.session.shell({ sessionID, command }), serverId)
 }
 
 export const SIDE_QUESTION_INSTRUCTIONS =
@@ -216,26 +244,29 @@ export async function askSideQuestion(
   sessionID: string,
   question: string,
   signal?: AbortSignal,
+  serverId?: string,
 ): Promise<string> {
-  const result = await callOpenCode((api) =>
-    api.session.generate(
-      { sessionID, prompt: [SIDE_QUESTION_INSTRUCTIONS, question].join('\n\n') },
-      signal ? { signal } : undefined,
-    ),
+  const result = await callOpenCode(
+    (api) =>
+      api.session.generate(
+        { sessionID, prompt: [SIDE_QUESTION_INSTRUCTIONS, question].join('\n\n') },
+        signal ? { signal } : undefined,
+      ),
+    serverId,
   )
   return result.text.trim()
 }
 
-export async function interruptSession(sessionID: string): Promise<void> {
-  await callOpenCode((api) => api.session.interrupt({ sessionID }))
+export async function interruptSession(sessionID: string, serverId?: string): Promise<void> {
+  await callOpenCode((api) => api.session.interrupt({ sessionID }), serverId)
 }
 
-export async function backgroundSession(sessionID: string): Promise<void> {
-  await callOpenCode((api) => api.session.background({ sessionID }))
+export async function backgroundSession(sessionID: string, serverId?: string): Promise<void> {
+  await callOpenCode((api) => api.session.background({ sessionID }), serverId)
 }
 
-export async function listShells(directory: string): Promise<ShellInfo[]> {
-  const { data } = await callOpenCode((api) => api.shell.list(openCodeLocation(directory)))
+export async function listShells(directory: string, serverId?: string): Promise<ShellInfo[]> {
+  const { data } = await callOpenCode((api) => api.shell.list(openCodeLocation(directory)), serverId)
   return data
 }
 
@@ -244,60 +275,72 @@ export async function readShellOutput(
   directory: string,
   cursor: number,
   limit: number,
+  serverId?: string,
 ): Promise<ShellOutputChunk> {
-  const { data } = await callOpenCode((api) =>
-    api.shell.output({ id, cursor, limit, ...openCodeLocation(directory) }),
+  const { data } = await callOpenCode(
+    (api) => api.shell.output({ id, cursor, limit, ...openCodeLocation(directory) }),
+    serverId,
   )
   return data
 }
 
-export async function removeShell(id: string, directory: string): Promise<void> {
-  await callOpenCode((api) => api.shell.remove({ id, ...openCodeLocation(directory) }))
+export async function removeShell(id: string, directory: string, serverId?: string): Promise<void> {
+  await callOpenCode((api) => api.shell.remove({ id, ...openCodeLocation(directory) }), serverId)
 }
 
-export async function stageRevert(sessionID: string, messageID: string): Promise<SessionRevert> {
-  await interruptSession(sessionID)
-  await callOpenCode((api) => api.session.wait({ sessionID }))
-  return callOpenCode((api) => api.session.revert.stage({ sessionID, messageID }))
+export async function stageRevert(
+  sessionID: string,
+  messageID: string,
+  serverId?: string,
+): Promise<SessionRevert> {
+  await interruptSession(sessionID, serverId)
+  await callOpenCode((api) => api.session.wait({ sessionID }), serverId)
+  return callOpenCode((api) => api.session.revert.stage({ sessionID, messageID }), serverId)
 }
 
-export async function commitRevert(sessionID: string): Promise<void> {
-  await callOpenCode((api) => api.session.revert.commit({ sessionID }))
+export async function commitRevert(sessionID: string, serverId?: string): Promise<void> {
+  await callOpenCode((api) => api.session.revert.commit({ sessionID }), serverId)
 }
 
-export async function clearRevert(sessionID: string): Promise<void> {
-  await callOpenCode((api) => api.session.revert.clear({ sessionID }))
+export async function clearRevert(sessionID: string, serverId?: string): Promise<void> {
+  await callOpenCode((api) => api.session.revert.clear({ sessionID }), serverId)
 }
 
-export async function compactSession(sessionID: string): Promise<SessionInboxCompaction> {
-  return callOpenCode((api) => api.session.compact({ sessionID }))
+export async function compactSession(sessionID: string, serverId?: string): Promise<SessionInboxCompaction> {
+  return callOpenCode((api) => api.session.compact({ sessionID }), serverId)
 }
 
-export async function activateSkill(sessionID: string, id: string): Promise<void> {
-  await callOpenCode((api) => api.session.skill({ sessionID, id }))
+export async function activateSkill(sessionID: string, id: string, serverId?: string): Promise<void> {
+  await callOpenCode((api) => api.session.skill({ sessionID, id }), serverId)
 }
 
-export async function listActiveSessions(): Promise<ActiveSessions> {
-  return callOpenCode((api) => api.session.active())
+export async function listActiveSessions(serverId?: string): Promise<ActiveSessions> {
+  return callOpenCode((api) => api.session.active(), serverId)
 }
 
-export async function listAgents(directory?: string): Promise<AgentInfo[]> {
-  const { data } = await callOpenCode((api) => api.agent.list(openCodeLocation(directory)))
+export async function listAgents(directory?: string, serverId?: string): Promise<AgentInfo[]> {
+  const { data } = await callOpenCode((api) => api.agent.list(openCodeLocation(directory)), serverId)
   return data
 }
 
-export async function listCommands(directory?: string): Promise<CommandInfo[]> {
-  const { data } = await callOpenCode((api) => api.command.list(openCodeLocation(directory)))
+export async function listCommands(directory?: string, serverId?: string): Promise<CommandInfo[]> {
+  const { data } = await callOpenCode((api) => api.command.list(openCodeLocation(directory)), serverId)
   return data
 }
 
-export async function listSkills(directory?: string): Promise<SkillInfo[]> {
-  const { data } = await callOpenCode((api) => api.skill.list(openCodeLocation(directory)))
+export async function listSkills(directory?: string, serverId?: string): Promise<SkillInfo[]> {
+  const { data } = await callOpenCode((api) => api.skill.list(openCodeLocation(directory)), serverId)
   return data
 }
 
-export async function listPendingPermissions(directory: string): Promise<PermissionRequest[]> {
-  const { data } = await callOpenCode((api) => api.permission.request.list(openCodeLocation(directory)))
+export async function listPendingPermissions(
+  directory: string,
+  serverId?: string,
+): Promise<PermissionRequest[]> {
+  const { data } = await callOpenCode(
+    (api) => api.permission.request.list(openCodeLocation(directory)),
+    serverId,
+  )
   return data
 }
 
@@ -306,38 +349,48 @@ export async function replyPermission(
   requestID: string,
   decision: 'once' | 'always' | 'reject',
   message?: string,
+  serverId?: string,
 ): Promise<void> {
-  await callOpenCode((api) =>
-    api.permission.reply({
-      sessionID,
-      requestID,
-      decision,
-      ...(message ? { message } : {}),
-    }),
+  await callOpenCode(
+    (api) =>
+      api.permission.reply({
+        sessionID,
+        requestID,
+        decision,
+        ...(message ? { message } : {}),
+      }),
+    serverId,
   )
 }
 
-export async function listPendingForms(directory: string): Promise<FormInfo[]> {
-  const { data } = await callOpenCode((api) => api.form.list(openCodeLocation(directory)))
+export async function listPendingForms(directory: string, serverId?: string): Promise<FormInfo[]> {
+  const { data } = await callOpenCode((api) => api.form.list(openCodeLocation(directory)), serverId)
   return data
 }
 
-export async function replyForm(sessionID: string, formID: string, answer: FormAnswer): Promise<void> {
-  await callOpenCode((api) => api.session.form.reply({ sessionID, formID, answer }))
+export async function replyForm(
+  sessionID: string,
+  formID: string,
+  answer: FormAnswer,
+  serverId?: string,
+): Promise<void> {
+  await callOpenCode((api) => api.session.form.reply({ sessionID, formID, answer }), serverId)
 }
 
-export async function cancelForm(sessionID: string, formID: string): Promise<void> {
-  await callOpenCode((api) => api.session.form.cancel({ sessionID, formID }))
+export async function cancelForm(sessionID: string, formID: string, serverId?: string): Promise<void> {
+  await callOpenCode((api) => api.session.form.cancel({ sessionID, formID }), serverId)
 }
 
-export async function findFiles(input: FindFilesInput): Promise<string[]> {
-  const { data } = await callOpenCode((api) =>
-    api.file.find({
-      ...openCodeLocation(input.directory),
-      query: input.query,
-      type: 'file',
-      limit: input.limit,
-    }),
+export async function findFiles(input: FindFilesInput, serverId?: string): Promise<string[]> {
+  const { data } = await callOpenCode(
+    (api) =>
+      api.file.find({
+        ...openCodeLocation(input.directory),
+        query: input.query,
+        type: 'file',
+        limit: input.limit,
+      }),
+    serverId,
   )
   return data.map((entry) => entry.path)
 }
@@ -345,22 +398,25 @@ export async function findFiles(input: FindFilesInput): Promise<string[]> {
 export async function listSessionMessages(
   sessionID: string,
   input: SessionMessagesInput = {},
+  serverId?: string,
 ): Promise<SessionMessagesPage> {
-  const { data, cursor } = await callOpenCode((api) =>
-    api.message.list({
-      sessionID,
-      ...(input.limit === undefined ? {} : { limit: input.limit }),
-      ...(input.cursor === undefined ? { order: 'desc' as const } : { cursor: input.cursor }),
-    }),
+  const { data, cursor } = await callOpenCode(
+    (api) =>
+      api.message.list({
+        sessionID,
+        ...(input.limit === undefined ? {} : { limit: input.limit }),
+        ...(input.cursor === undefined ? { order: 'desc' as const } : { cursor: input.cursor }),
+      }),
+    serverId,
   )
   return { messages: [...data].reverse(), nextCursor: cursor.next ?? undefined }
 }
 
-export async function readSessionSnapshot(sessionID: string): Promise<SessionSnapshot> {
+export async function readSessionSnapshot(sessionID: string, serverId?: string): Promise<SessionSnapshot> {
   const [page, pending, active] = await Promise.all([
-    listSessionMessages(sessionID),
-    callOpenCode((api) => api.session.inbox.list({ sessionID })),
-    listActiveSessions(),
+    listSessionMessages(sessionID, {}, serverId),
+    callOpenCode((api) => api.session.inbox.list({ sessionID }), serverId),
+    listActiveSessions(serverId),
   ])
   return {
     messages: page.messages,
diff --git a/frontend/src/api/opencodeApi.test.ts b/frontend/src/api/opencodeApi.test.ts
new file mode 100644
index 000000000..279d2225b
--- /dev/null
+++ b/frontend/src/api/opencodeApi.test.ts
@@ -0,0 +1,28 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { getOpenCodeApi, openCodeApiBaseUrl } from './opencodeApi'
+import { API_BASE_URL, OPENCODE_API_ENDPOINT } from '@/config'
+
+describe('openCodeApi', () => {
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('keeps the local server on the direct OpenCode endpoint', () => {
+    expect(openCodeApiBaseUrl()).toBe(OPENCODE_API_ENDPOINT)
+    expect(openCodeApiBaseUrl('local')).toBe(OPENCODE_API_ENDPOINT)
+  })
+
+  it('routes remote servers through the backend proxy', () => {
+    expect(openCodeApiBaseUrl('srv_abc')).toBe(`${API_BASE_URL}/api/opencode/servers/srv_abc`)
+  })
+
+  it('memoizes one client per server', () => {
+    const local = getOpenCodeApi()
+    const remote = getOpenCodeApi('srv_abc')
+
+    expect(getOpenCodeApi()).toBe(local)
+    expect(getOpenCodeApi('local')).toBe(local)
+    expect(getOpenCodeApi('srv_abc')).toBe(remote)
+    expect(getOpenCodeApi('srv_other')).not.toBe(remote)
+  })
+})
diff --git a/frontend/src/api/opencodeApi.ts b/frontend/src/api/opencodeApi.ts
index e590c5f12..c55d5fad7 100644
--- a/frontend/src/api/opencodeApi.ts
+++ b/frontend/src/api/opencodeApi.ts
@@ -1,11 +1,28 @@
 import { ClientError, createOpenCodeApi, openCodeErrorStatus, type OpenCodeApi } from '@opencode-manager/shared/opencode'
 import { FetchError } from '@opencode-manager/shared'
-import { OPENCODE_API_ENDPOINT } from '@/config'
+import { LOCAL_OPENCODE_SERVER_ID } from '@opencode-manager/shared/schemas'
+import { API_BASE_URL, OPENCODE_API_ENDPOINT } from '@/config'
 
-const openCodeApi = createOpenCodeApi({
-  baseUrl: new URL(OPENCODE_API_ENDPOINT, window.location.origin).toString(),
-  fetch: (input, init) => fetch(input, { ...init, credentials: 'include' }),
-})
+const openCodeApis = new Map<string, OpenCodeApi>()
+
+/** Base URL of the OpenCode API for a server: the direct local endpoint or the remote proxy. */
+export function openCodeApiBaseUrl(serverId: string = LOCAL_OPENCODE_SERVER_ID): string {
+  return serverId === LOCAL_OPENCODE_SERVER_ID
+    ? OPENCODE_API_ENDPOINT
+    : `${API_BASE_URL}/api/opencode/servers/${encodeURIComponent(serverId)}`
+}
+
+export function getOpenCodeApi(serverId: string = LOCAL_OPENCODE_SERVER_ID): OpenCodeApi {
+  const cached = openCodeApis.get(serverId)
+  if (cached) return cached
+
+  const api = createOpenCodeApi({
+    baseUrl: new URL(openCodeApiBaseUrl(serverId), window.location.origin).toString(),
+    fetch: (input, init) => fetch(input, { ...init, credentials: 'include' }),
+  })
+  openCodeApis.set(serverId, api)
+  return api
+}
 
 function toFetchError(error: unknown): FetchError {
   if (error instanceof FetchError) {
@@ -25,9 +42,12 @@ function toFetchError(error: unknown): FetchError {
   return new FetchError('Request failed', status ?? 0)
 }
 
-export async function callOpenCode<T>(operation: (api: OpenCodeApi) => Promise<T>): Promise<T> {
+export async function callOpenCode<T>(
+  operation: (api: OpenCodeApi) => Promise<T>,
+  serverId: string = LOCAL_OPENCODE_SERVER_ID,
+): Promise<T> {
   try {
-    return await operation(openCodeApi)
+    return await operation(getOpenCodeApi(serverId))
   } catch (error) {
     throw toFetchError(error)
   }
diff --git a/frontend/src/api/opencodeServers.test.ts b/frontend/src/api/opencodeServers.test.ts
new file mode 100644
index 000000000..c67fdfb7c
--- /dev/null
+++ b/frontend/src/api/opencodeServers.test.ts
@@ -0,0 +1,129 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  createOpenCodeServer,
+  deleteOpenCodeServer,
+  listOpenCodeServers,
+  testOpenCodeServer,
+  testOpenCodeServerById,
+  updateOpenCodeServer,
+} from './opencodeServers'
+
+const jsonResponse = (body: unknown, status = 200) =>
+  new Response(JSON.stringify(body), {
+    status,
+    headers: { 'Content-Type': 'application/json' },
+  })
+
+const server = {
+  id: 'srv_1',
+  name: 'Kitchen',
+  baseUrl: 'https://kitchen.example.com',
+  username: 'opencode',
+  enabled: true,
+  hasPassword: true,
+  createdAt: 1,
+  updatedAt: 2,
+}
+
+const testResult = { ok: true, version: '2.0.15', versionSupported: true, error: null }
+
+describe('opencodeServers', () => {
+  const fetchMock = vi.fn()
+
+  beforeEach(() => {
+    fetchMock.mockReset()
+    vi.stubGlobal('fetch', fetchMock)
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('lists servers from the { servers } envelope', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({ servers: [server] }))
+
+    await expect(listOpenCodeServers()).resolves.toEqual([server])
+    expect(fetchMock.mock.calls[0][0]).toEqual(expect.stringContaining('/api/opencode-servers'))
+    expect(fetchMock.mock.calls[0][1].method).toBeUndefined()
+  })
+
+  it('creates a server and returns the test result', async () => {
+    const input = {
+      name: 'Kitchen',
+      baseUrl: 'https://kitchen.example.com',
+      username: 'opencode',
+      password: 'secret',
+      enabled: true,
+    }
+    fetchMock.mockResolvedValue(jsonResponse({ server, test: testResult }, 201))
+
+    await expect(createOpenCodeServer(input)).resolves.toEqual({ server, test: testResult })
+
+    const [url, options] = fetchMock.mock.calls[0]
+    expect(url).toEqual(expect.stringContaining('/api/opencode-servers'))
+    expect(options.method).toBe('POST')
+    expect(options.headers['Content-Type']).toBe('application/json')
+    expect(JSON.parse(options.body)).toEqual(input)
+  })
+
+  it('unwraps the { server } envelope on PATCH', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({ server: { ...server, name: 'Office' } }))
+
+    await expect(updateOpenCodeServer('srv_1', { name: 'Office' })).resolves.toEqual({
+      ...server,
+      name: 'Office',
+    })
+
+    const [url, options] = fetchMock.mock.calls[0]
+    expect(url).toEqual(expect.stringContaining('/api/opencode-servers/srv_1'))
+    expect(options.method).toBe('PATCH')
+    expect(JSON.parse(options.body)).toEqual({ name: 'Office' })
+  })
+
+  it('clears a password by sending null', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({ server: { ...server, hasPassword: false } }))
+
+    await updateOpenCodeServer('srv_1', { password: null })
+
+    const [, options] = fetchMock.mock.calls[0]
+    expect(JSON.parse(options.body)).toEqual({ password: null })
+  })
+
+  it('deletes a server with DELETE and accepts the empty 204 response', async () => {
+    fetchMock.mockResolvedValue(new Response(null, { status: 204 }))
+
+    await expect(deleteOpenCodeServer('srv_1')).resolves.toBeUndefined()
+
+    const [url, options] = fetchMock.mock.calls[0]
+    expect(url).toEqual(expect.stringContaining('/api/opencode-servers/srv_1'))
+    expect(options.method).toBe('DELETE')
+  })
+
+  it('tests unsaved values with POST /test', async () => {
+    fetchMock.mockResolvedValue(jsonResponse(testResult))
+    const input = { baseUrl: 'https://kitchen.example.com', username: 'opencode', password: 'secret' }
+
+    await expect(testOpenCodeServer(input)).resolves.toEqual(testResult)
+
+    const [url, options] = fetchMock.mock.calls[0]
+    expect(url).toEqual(expect.stringContaining('/api/opencode-servers/test'))
+    expect(options.method).toBe('POST')
+    expect(JSON.parse(options.body)).toEqual(input)
+  })
+
+  it('tests a saved server with POST /:id/test', async () => {
+    fetchMock.mockResolvedValue(jsonResponse(testResult))
+
+    await expect(testOpenCodeServerById('srv_1')).resolves.toEqual(testResult)
+
+    const [url, options] = fetchMock.mock.calls[0]
+    expect(url).toEqual(expect.stringContaining('/api/opencode-servers/srv_1/test'))
+    expect(options.method).toBe('POST')
+  })
+
+  it('surfaces backend error messages', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({ error: 'Server unreachable' }, 502))
+
+    await expect(testOpenCodeServerById('srv_1')).rejects.toThrow('Server unreachable')
+  })
+})
diff --git a/frontend/src/api/opencodeServers.ts b/frontend/src/api/opencodeServers.ts
new file mode 100644
index 000000000..b31234f5d
--- /dev/null
+++ b/frontend/src/api/opencodeServers.ts
@@ -0,0 +1,77 @@
+import type {
+  CreateOpenCodeServerRequest,
+  OpenCodeServer,
+  OpenCodeServerStatus,
+  OpenCodeServerTestResult,
+  TestOpenCodeServerRequest,
+  UpdateOpenCodeServerRequest,
+} from '@opencode-manager/shared/schemas'
+import { API_BASE_URL } from '@/config'
+import { fetchWrapper, fetchWrapperVoid } from './fetchWrapper'
+
+const OPENCODE_SERVERS_URL = `${API_BASE_URL}/api/opencode-servers`
+
+export interface CreateOpenCodeServerResponse {
+  server: OpenCodeServer
+  test: OpenCodeServerTestResult
+}
+
+export async function listOpenCodeServers(): Promise<OpenCodeServer[]> {
+  const response = await fetchWrapper<{ servers: OpenCodeServer[] }>(OPENCODE_SERVERS_URL)
+  return response.servers
+}
+
+export async function listOpenCodeServerStatuses(): Promise<OpenCodeServerStatus[]> {
+  const response = await fetchWrapper<{ statuses: OpenCodeServerStatus[] }>(
+    `${OPENCODE_SERVERS_URL}/status`,
+  )
+  return response.statuses
+}
+
+export async function createOpenCodeServer(
+  input: CreateOpenCodeServerRequest,
+): Promise<CreateOpenCodeServerResponse> {
+  return fetchWrapper<CreateOpenCodeServerResponse>(OPENCODE_SERVERS_URL, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(input),
+  })
+}
+
+export async function updateOpenCodeServer(
+  id: string,
+  input: UpdateOpenCodeServerRequest,
+): Promise<OpenCodeServer> {
+  const response = await fetchWrapper<{ server: OpenCodeServer }>(
+    `${OPENCODE_SERVERS_URL}/${encodeURIComponent(id)}`,
+    {
+      method: 'PATCH',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(input),
+    },
+  )
+  return response.server
+}
+
+export async function deleteOpenCodeServer(id: string): Promise<void> {
+  return fetchWrapperVoid(`${OPENCODE_SERVERS_URL}/${encodeURIComponent(id)}`, {
+    method: 'DELETE',
+  })
+}
+
+export async function testOpenCodeServer(
+  input: TestOpenCodeServerRequest,
+): Promise<OpenCodeServerTestResult> {
+  return fetchWrapper<OpenCodeServerTestResult>(`${OPENCODE_SERVERS_URL}/test`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(input),
+  })
+}
+
+export async function testOpenCodeServerById(id: string): Promise<OpenCodeServerTestResult> {
+  return fetchWrapper<OpenCodeServerTestResult>(
+    `${OPENCODE_SERVERS_URL}/${encodeURIComponent(id)}/test`,
+    { method: 'POST' },
+  )
+}
diff --git a/frontend/src/api/providers.ts b/frontend/src/api/providers.ts
index 919fa4e4b..e1906dfdc 100644
--- a/frontend/src/api/providers.ts
+++ b/frontend/src/api/providers.ts
@@ -59,11 +59,12 @@ function mapModelInfo(model: ModelInfo): Model {
   };
 }
 
-export async function getProviders(directory?: string): Promise<ProviderCatalog> {
+export async function getProviders(directory?: string, serverId?: string): Promise<ProviderCatalog> {
   try {
     const location = openCodeLocation(directory);
-    const [providerResult, modelResult] = await callOpenCode((api) =>
-      Promise.all([api.provider.list(location), api.model.list(location)]),
+    const [providerResult, modelResult] = await callOpenCode(
+      (api) => Promise.all([api.provider.list(location), api.model.list(location)]),
+      serverId,
     );
 
     const activeProviders = providerResult.data.filter(isActiveCatalogProvider);
@@ -100,9 +101,12 @@ export async function getProviders(directory?: string): Promise<ProviderCatalog>
   }
 }
 
-export async function getOpenCodeConfiguredModel(directory?: string): Promise<string | null> {
+export async function getOpenCodeConfiguredModel(
+  directory?: string,
+  serverId?: string,
+): Promise<string | null> {
   try {
-    const entries = await callOpenCode((api) => api.config.get(openCodeLocation(directory)));
+    const entries = await callOpenCode((api) => api.config.get(openCodeLocation(directory)), serverId);
     const ref = selectConfiguredModelRef(entries);
     return ref ? formatOpenCodeModelRef(ref) : null;
   } catch {
@@ -110,9 +114,12 @@ export async function getOpenCodeConfiguredModel(directory?: string): Promise<st
   }
 }
 
-export async function getOpenCodeServerDefaultModel(directory?: string): Promise<ModelRef | null> {
+export async function getOpenCodeServerDefaultModel(
+  directory?: string,
+  serverId?: string,
+): Promise<ModelRef | null> {
   try {
-    const result = await callOpenCode((api) => api.model.default(openCodeLocation(directory)));
+    const result = await callOpenCode((api) => api.model.default(openCodeLocation(directory)), serverId);
     const model = result.data;
     return model ? { providerID: model.providerID, id: model.id } : null;
   } catch {
diff --git a/frontend/src/components/activity/ActivityList.test.tsx b/frontend/src/components/activity/ActivityList.test.tsx
index 313525326..55450ada8 100644
--- a/frontend/src/components/activity/ActivityList.test.tsx
+++ b/frontend/src/components/activity/ActivityList.test.tsx
@@ -45,9 +45,12 @@ function createRepo(id: number, name: string): Repo {
 function createItem(
   overrides: Partial<ActiveWorkItem> & Pick<ActiveWorkItem, 'state' | 'session' | 'repo'>,
 ): ActiveWorkItem {
+  const repoId = overrides.repo?.id ?? 0
   return {
-    key: `${overrides.repo.id}:${overrides.session.id}`,
-    path: `/repos/${overrides.repo.id}/sessions/${overrides.session.id}`,
+    key: `${repoId}:${overrides.session.id}`,
+    serverId: null,
+    serverName: null,
+    path: `/repos/${repoId}/sessions/${overrides.session.id}`,
     updatedAt: overrides.session.time.updated,
     ...overrides,
   }
@@ -175,6 +178,24 @@ describe('ActivityList', () => {
     expect(screen.getByRole('button', { name: /Other session/ })).not.toHaveAttribute('aria-current')
   })
 
+  it('labels a remote row with its server name and marks it current on its server route', () => {
+    const item = createItem({
+      state: 'needs-input',
+      session: createSession('s1', 'Remote session'),
+      repo: null,
+      serverId: 'srv_kitchen',
+      serverName: 'Kitchen',
+      path: '/servers/srv_kitchen/sessions/s1',
+    })
+    setGroups({ needsInput: [item] })
+
+    renderList(vi.fn(), '/servers/srv_kitchen/sessions/s1')
+
+    const row = screen.getByRole('button', { name: /Remote session/ })
+    expect(row).toHaveTextContent('Kitchen')
+    expect(row).toHaveAttribute('aria-current', 'true')
+  })
+
   it('shows a loading state', () => {
     mocks.useActiveWork.mockReturnValue({
       groups: { needsInput: [], running: [], recent: [] },
diff --git a/frontend/src/components/activity/ActivityList.tsx b/frontend/src/components/activity/ActivityList.tsx
index 00654c78e..55cb5f85e 100644
--- a/frontend/src/components/activity/ActivityList.tsx
+++ b/frontend/src/components/activity/ActivityList.tsx
@@ -2,7 +2,7 @@ import { useLocation } from 'react-router-dom'
 import { CircleAlert, CircleCheck, CircleX } from 'lucide-react'
 import { useActiveWork } from '@/hooks/useActiveWork'
 import { SessionStatusIndicator } from '@/components/ui/session-status-indicator'
-import { parseRepoRoute } from '@/lib/navigation'
+import { parseRepoRoute, parseServerSessionRoute } from '@/lib/navigation'
 import { cn, formatShortRelativeTime, getRepoBranchLabel, getRepoDisplayName } from '@/lib/utils'
 import {
   ACTIVE_WORK_GROUPS,
@@ -28,8 +28,27 @@ interface ActivityListProps {
   variant?: 'full' | 'compact'
 }
 
-function isCurrentItem(item: ActiveWorkItem, sessionID: string | null, repoID: number | null) {
-  return item.repo.id === repoID && item.session.id === sessionID
+function isCurrentItem(
+  item: ActiveWorkItem,
+  sessionID: string | null,
+  repoID: number | null,
+  serverID: string | null,
+) {
+  if (item.session.id !== sessionID) return false
+  if (item.serverId) return item.serverId === serverID
+  return item.repo?.id === repoID
+}
+
+/** The row's short label: the local repo's name or the owning linked server's name. */
+function activityItemLabel(item: ActiveWorkItem): string {
+  return item.repo ? getRepoDisplayName(item.repo) : item.serverName ?? item.serverId ?? ''
+}
+
+/** The row's identifying line: a local repo with its branch, or the owning linked server's name. */
+function activityItemLine(item: ActiveWorkItem): string {
+  if (!item.repo) return activityItemLabel(item)
+  const branch = item.worktreeBranch ?? getRepoBranchLabel(item.repo)
+  return branch ? `${getRepoDisplayName(item.repo)} · ${branch}` : getRepoDisplayName(item.repo)
 }
 
 function activityRowClass(isCurrent: boolean, compact: boolean) {
@@ -63,11 +82,6 @@ interface ActivityRowProps {
 }
 
 function ActivityRow({ item, isCurrent, onSelect }: ActivityRowProps) {
-  const branch = item.worktreeBranch ?? getRepoBranchLabel(item.repo)
-  const repoLine = branch
-    ? `${getRepoDisplayName(item.repo)} · ${branch}`
-    : getRepoDisplayName(item.repo)
-
   return (
     <button
       type="button"
@@ -82,7 +96,7 @@ function ActivityRow({ item, isCurrent, onSelect }: ActivityRowProps) {
         <span className="block truncate text-foreground">
           {item.session.title || UNTITLED_SESSION_TITLE}
         </span>
-        <span className="block truncate text-xs text-muted-foreground">{repoLine}</span>
+        <span className="block truncate text-xs text-muted-foreground">{activityItemLine(item)}</span>
       </span>
       <span className="shrink-0 text-xs text-muted-foreground">
         {formatShortRelativeTime(new Date(item.updatedAt))}
@@ -106,7 +120,7 @@ function CompactActivityRow({ item, isCurrent, onSelect }: ActivityRowProps) {
         {item.session.title || UNTITLED_SESSION_TITLE}
       </span>
       <span className="max-w-[35%] truncate text-xs text-muted-foreground">
-        {getRepoDisplayName(item.repo)}
+        {activityItemLabel(item)}
       </span>
       <span className="shrink-0 text-xs text-muted-foreground">
         {formatShortRelativeTime(new Date(item.updatedAt))}
@@ -120,10 +134,18 @@ interface ActivityGroupProps {
   items: ActiveWorkItem[]
   currentSessionID: string | null
   currentRepoId: number | null
+  currentServerId: string | null
   onSelect: (item: ActiveWorkItem) => void
 }
 
-function ActivityGroup({ heading, items, currentSessionID, currentRepoId, onSelect }: ActivityGroupProps) {
+function ActivityGroup({
+  heading,
+  items,
+  currentSessionID,
+  currentRepoId,
+  currentServerId,
+  onSelect,
+}: ActivityGroupProps) {
   if (items.length === 0) return null
 
   return (
@@ -133,7 +155,7 @@ function ActivityGroup({ heading, items, currentSessionID, currentRepoId, onSele
         <ActivityRow
           key={item.key}
           item={item}
-          isCurrent={isCurrentItem(item, currentSessionID, currentRepoId)}
+          isCurrent={isCurrentItem(item, currentSessionID, currentRepoId, currentServerId)}
           onSelect={onSelect}
         />
       ))}
@@ -152,6 +174,8 @@ export function ActivityList({
   const { groups, isLoading, isError } = useActiveWork(minutes * MS_PER_MINUTE)
 
   const route = parseRepoRoute(location.pathname)
+  const serverRoute = parseServerSessionRoute(location.pathname)
+  const currentSessionID = route.sessionId ?? serverRoute?.sessionId ?? null
 
   if (isLoading) {
     if (hideWhenEmpty) return null
@@ -199,7 +223,7 @@ export function ActivityList({
           <CompactActivityRow
             key={item.key}
             item={item}
-            isCurrent={isCurrentItem(item, route.sessionId, route.repoId)}
+            isCurrent={isCurrentItem(item, currentSessionID, route.repoId, serverRoute?.serverId ?? null)}
             onSelect={onNavigate}
           />
         ))
@@ -210,8 +234,9 @@ export function ActivityList({
               key={group.key}
               heading={group.heading}
               items={groups[group.key]}
-              currentSessionID={route.sessionId}
+              currentSessionID={currentSessionID}
               currentRepoId={route.repoId}
+              currentServerId={serverRoute?.serverId ?? null}
               onSelect={onNavigate}
             />
           ))}
diff --git a/frontend/src/components/message/ComposerToolsMenu.tsx b/frontend/src/components/message/ComposerToolsMenu.tsx
index f5eb451be..70b201f94 100644
--- a/frontend/src/components/message/ComposerToolsMenu.tsx
+++ b/frontend/src/components/message/ComposerToolsMenu.tsx
@@ -25,6 +25,7 @@ interface ComposerToolsMenuProps {
   onToggleGoal: () => void
   onAttachFile: () => void
   onDictate?: () => void
+  allowManagerTools?: boolean
 }
 
 export function ComposerToolsMenu({
@@ -36,9 +37,10 @@ export function ComposerToolsMenu({
   onToggleGoal,
   onAttachFile,
   onDictate,
+  allowManagerTools = true,
 }: ComposerToolsMenuProps) {
-  const permission = usePermissionModeToggle(sessionID, directory)
-  const sandbox = useSandboxToggle(sessionID)
+  const permission = usePermissionModeToggle(sessionID, directory, { enabled: allowManagerTools })
+  const sandbox = useSandboxToggle(sessionID, { enabled: allowManagerTools })
   const [resourcesOpen, setResourcesOpen] = useState(false)
 
   return (
@@ -55,26 +57,30 @@ export function ComposerToolsMenu({
           </button>
         </DropdownMenuTrigger>
         <DropdownMenuContent side="top" align="end" collisionPadding={8} className="w-64">
-          <DropdownMenuCheckboxItem
-            checked={permission.isAuto}
-            disabled={permission.disabled}
-            onCheckedChange={permission.toggle}
-          >
-            <ToolMenuItemContent
-              icon={permission.isAuto ? <ShieldCheck className="h-4 w-4" /> : <Shield className="h-4 w-4" />}
-              title="Accept all permissions"
-              detail={permission.disabled ? permission.label : undefined}
-            />
-          </DropdownMenuCheckboxItem>
-          <SandboxMenuItems sandbox={sandbox} onOpenResources={() => setResourcesOpen(true)} />
-          <DropdownMenuCheckboxItem checked={goalArmed} disabled={goalDisabled} onCheckedChange={onToggleGoal}>
-            <ToolMenuItemContent
-              icon={<Target className="h-4 w-4" />}
-              title="Goal mode"
-              detail={goalDisabled ? goalLabel : undefined}
-            />
-          </DropdownMenuCheckboxItem>
-          <DropdownMenuSeparator />
+          {allowManagerTools ? (
+            <>
+              <DropdownMenuCheckboxItem
+                checked={permission.isAuto}
+                disabled={permission.disabled}
+                onCheckedChange={permission.toggle}
+              >
+                <ToolMenuItemContent
+                  icon={permission.isAuto ? <ShieldCheck className="h-4 w-4" /> : <Shield className="h-4 w-4" />}
+                  title="Accept all permissions"
+                  detail={permission.disabled ? permission.label : undefined}
+                />
+              </DropdownMenuCheckboxItem>
+              <SandboxMenuItems sandbox={sandbox} onOpenResources={() => setResourcesOpen(true)} />
+              <DropdownMenuCheckboxItem checked={goalArmed} disabled={goalDisabled} onCheckedChange={onToggleGoal}>
+                <ToolMenuItemContent
+                  icon={<Target className="h-4 w-4" />}
+                  title="Goal mode"
+                  detail={goalDisabled ? goalLabel : undefined}
+                />
+              </DropdownMenuCheckboxItem>
+              <DropdownMenuSeparator />
+            </>
+          ) : null}
           <DropdownMenuItem onSelect={onAttachFile} className="pl-8">
             <ToolMenuItemContent icon={<Paperclip className="h-4 w-4" />} title="Attach image or PDF" />
           </DropdownMenuItem>
diff --git a/frontend/src/components/message/FileReferenceText.tsx b/frontend/src/components/message/FileReferenceText.tsx
index 344f17318..85108b6e7 100644
--- a/frontend/src/components/message/FileReferenceText.tsx
+++ b/frontend/src/components/message/FileReferenceText.tsx
@@ -8,6 +8,7 @@ interface FileReferenceTextProps {
 
 export function FileReferenceText({ text, onFileClick }: FileReferenceTextProps) {
   const parts = useMemo(() => {
+    if (!onFileClick) return text
     const references = detectFileReferences(text)
     if (references.length === 0) return text
 
diff --git a/frontend/src/components/message/FileToolRender.tsx b/frontend/src/components/message/FileToolRender.tsx
index aa8895081..3b67c708e 100644
--- a/frontend/src/components/message/FileToolRender.tsx
+++ b/frontend/src/components/message/FileToolRender.tsx
@@ -1,6 +1,7 @@
 import React, { useState } from 'react'
 import type { FileDiffInfo, SessionMessageAssistantTool } from '@opencode-manager/shared/opencode'
 import { useSettings } from '@/hooks/useSettings'
+import { isLocalOpenCodeServer, useOpenCodeServerId } from '@/contexts/OpenCodeServerContext'
 import { DiffStats } from './DiffStats'
 import { CodePreview } from './CodePreview'
 import { ToolContentFiles } from './ToolContentFiles'
@@ -73,10 +74,12 @@ interface FileToolRenderProps {
 
 function FileToolRender({ part, filediff, filePath, content, toolName, onFileClick }: FileToolRenderProps) {
   const { preferences } = useSettings()
+  const isRemoteServer = !isLocalOpenCodeServer(useOpenCodeServerId())
   const isReadTool = toolName === 'Read'
   const isEditTool = toolName === 'Edit'
   const isWriteTool = toolName === 'Write'
   const hasExpandableContent = !isReadTool && (filediff || content)
+  const isFileLink = Boolean(onFileClick) && !isRemoteServer
   
   const isFileMutatingTool = isEditTool || isWriteTool
   const defaultExpanded = isFileMutatingTool
@@ -106,12 +109,16 @@ function FileToolRender({ part, filediff, filePath, content, toolName, onFileCli
           <span className="text-success flex-shrink-0">✓</span>
           <span className="font-medium flex-shrink-0">{toolName}</span>
           {filePath && (
-            <span 
-              onClick={handleFileClick}
-              className="text-primary text-xs truncate hover:underline cursor-pointer"
-            >
-              {getRelativePath(filePath)}
-            </span>
+            isFileLink ? (
+              <span
+                onClick={handleFileClick}
+                className="text-primary text-xs truncate hover:underline cursor-pointer"
+              >
+                {getRelativePath(filePath)}
+              </span>
+            ) : (
+              <span className="text-muted-foreground text-xs truncate">{getRelativePath(filePath)}</span>
+            )
           )}
         </div>
         <div className="flex items-center gap-2 flex-shrink-0">
diff --git a/frontend/src/components/message/MessagePart.test.tsx b/frontend/src/components/message/MessagePart.test.tsx
index e98347993..a6c7a2b32 100644
--- a/frontend/src/components/message/MessagePart.test.tsx
+++ b/frontend/src/components/message/MessagePart.test.tsx
@@ -4,6 +4,7 @@ import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
 import { MemoryRouter } from 'react-router-dom'
 import { MessagePart } from './MessagePart'
 import { getFileApiUrl } from '@/api/files'
+import { OpenCodeServerProvider } from '@/contexts/OpenCodeServerContext'
 import { applySessionEvent, emptySessionTranscript } from '@/lib/session-projection'
 import { promptSequence } from '@/test/fixtures/session-projection'
 import type {
@@ -509,6 +510,36 @@ describe('MessagePart', () => {
   })
 
   describe('file tools', () => {
+    it('renders a linked-server file name as plain text', () => {
+      const onFileClick = vi.fn()
+      const queryClient = new QueryClient()
+      render(
+        <QueryClientProvider client={queryClient}>
+          <MemoryRouter>
+            <OpenCodeServerProvider serverId="srv_kitchen">
+              <MessagePart
+                part={toolPart('read', {
+                  status: 'completed',
+                  input: { path: '/srv/app/src/a.ts' },
+                  content: [{ type: 'text', text: 'file contents' }],
+                  metadata: {},
+                })}
+                onFileClick={onFileClick}
+              />
+            </OpenCodeServerProvider>
+          </MemoryRouter>
+        </QueryClientProvider>,
+      )
+
+      const fileName = screen.getByText('/srv/app/src/a.ts')
+      expect(fileName.className).not.toContain('cursor-pointer')
+      expect(fileName.className).not.toContain('text-primary')
+
+      fireEvent.click(fileName)
+
+      expect(onFileClick).not.toHaveBeenCalled()
+    })
+
     it('renders an edit tool diff', () => {
       renderWithProviders(
         <MessagePart
diff --git a/frontend/src/components/message/PromptInput.mention.test.tsx b/frontend/src/components/message/PromptInput.mention.test.tsx
index 882d48481..237b44fa5 100644
--- a/frontend/src/components/message/PromptInput.mention.test.tsx
+++ b/frontend/src/components/message/PromptInput.mention.test.tsx
@@ -212,7 +212,7 @@ describe('PromptInput agent mention submission', () => {
       sessionID: 'test-session',
       text: 'ask @reviewer',
       agents: [{ name: 'reviewer', mention: { start: 4, end: 13, text: '@reviewer' } }],
-    }))
+    }), 'local')
     expect(mocks.switchSessionAgent).not.toHaveBeenCalled()
     expect(mocks.switchSessionModel).not.toHaveBeenCalled()
   })
@@ -231,7 +231,7 @@ describe('PromptInput agent mention submission', () => {
       text: 'ask @reviewer',
       agents: [{ name: 'reviewer', mention: { start: 4, end: 13, text: '@reviewer' } }],
       delivery: 'queue',
-    }))
+    }), 'local')
     expect(mocks.switchSessionAgent).not.toHaveBeenCalled()
   })
 
@@ -248,7 +248,7 @@ describe('PromptInput agent mention submission', () => {
       text: 'use @pr-review and @pr-review',
       agents: [],
       skills: [{ id: 'pr-review', mention: { start: 4, end: 14, text: '@pr-review' } }],
-    }))
+    }), 'local')
   })
 
   it('sends plain text without inferring an agent attachment or switching', async () => {
@@ -264,7 +264,7 @@ describe('PromptInput agent mention submission', () => {
       sessionID: 'test-session',
       text: 'plain text',
       agents: [],
-    }))
+    }), 'local')
     expect(mocks.switchSessionAgent).not.toHaveBeenCalled()
     expect(mocks.switchSessionModel).not.toHaveBeenCalled()
   })
diff --git a/frontend/src/components/message/PromptInput.tsx b/frontend/src/components/message/PromptInput.tsx
index a86720bc2..7702fdc9f 100644
--- a/frontend/src/components/message/PromptInput.tsx
+++ b/frontend/src/components/message/PromptInput.tsx
@@ -18,6 +18,7 @@ import { useMobile } from '@/hooks/useMobile'
 import { FINE_POINTER_MEDIA_QUERY, useMediaQuery } from '@/hooks/useMediaQuery'
 
 import { usePermissions } from '@/contexts/EventContext'
+import { isLocalOpenCodeServer, useOpenCodeServerId } from '@/contexts/OpenCodeServerContext'
 import { ArrowDown, Upload, X, Mic, MicOff, Target } from 'lucide-react'
 
 import { SquareFill } from '@/components/ui/square-fill'
@@ -251,6 +252,7 @@ export const PromptInput = memo(forwardRef<PromptInputHandle, PromptInputProps>(
 
   const sessionAgent = useSessionAgent(sessionID, directory)
   const hasBackgroundActivity = useHasBackgroundActivity(sessionID)
+  const allowManagerTools = isLocalOpenCodeServer(useOpenCodeServerId())
   const currentMode = localMode ?? sessionAgent.agent
   const setStoredAgent = useSessionAgentStore((s) => s.setAgent)
   const sendPrompt = useSendPrompt(directory)
@@ -258,8 +260,8 @@ export const PromptInput = memo(forwardRef<PromptInputHandle, PromptInputProps>(
   const startGoal = useStartSessionGoal()
   const isPromptSubmitPending = sendPrompt.isPending || sendShell.isPending || startGoal.isPending
   const interruptSession = useInterruptSession()
-  const { data: sessionGoal } = useSessionGoal(sessionID)
-  const { data: permissionMode } = useSessionPermissionMode(sessionID)
+  const { data: sessionGoal } = useSessionGoal(sessionID, { enabled: allowManagerTools })
+  const { data: permissionMode } = useSessionPermissionMode(sessionID, { enabled: allowManagerTools })
   const { searchCommands, findCommand, recentNames } = useCommands({ directory })
   const recordCommand = useRecentCommandsStore((state) => state.recordCommand)
   const isExactCommandPrompt = (value: string) => {
@@ -1577,7 +1579,7 @@ return (
                 onAgentChange={handleAgentChange}
                 isBashMode={isBashMode}
               />
-              {directory && !isMobile && (
+              {directory && !isMobile && allowManagerTools ? (
                 <>
                   <PermissionModeToggle sessionID={sessionID} directory={directory} />
                   <SessionSandboxMenu sessionID={sessionID} />
@@ -1590,7 +1592,7 @@ return (
                     <Target className="w-5 h-5" />
                   </IconToggleButton>
                 </>
-              )}
+              ) : null}
               {(isSessionActive || hasBackgroundActivity) && (
                 <div className="px-2.5 py-1.5 md:px-3 md:py-2 rounded-lg text-xs md:text-sm font-medium text-muted-foreground max-w-[120px] md:max-w-[180px]">
                   <SessionStatusIndicator sessionID={sessionID} showLabel />
@@ -1662,6 +1664,7 @@ return (
               goalLabel={goalButtonLabel}
               onToggleGoal={toggleGoalArmed}
               onAttachFile={openFilePicker}
+              allowManagerTools={allowManagerTools}
               onDictate={canUseMobileVoice && hasPromptContent && !showVoiceFeedback ? () => void startVoiceRecording() : undefined}
             />
           )}
diff --git a/frontend/src/components/navigation/DesktopSessionTree.test.tsx b/frontend/src/components/navigation/DesktopSessionTree.test.tsx
index f028c5cbb..9a37fcf38 100644
--- a/frontend/src/components/navigation/DesktopSessionTree.test.tsx
+++ b/frontend/src/components/navigation/DesktopSessionTree.test.tsx
@@ -299,7 +299,7 @@ describe('DesktopSessionTree', () => {
     const rows = screen.getAllByRole('button', { name: /Session / })
     expect(rows[0]).toHaveTextContent('Session old')
     expect(rows[0].querySelector('[aria-label="Pinned"]')).not.toBeNull()
-    expect(getSessionMock).toHaveBeenCalledWith('old')
+    expect(getSessionMock).toHaveBeenCalledWith('old', 'local')
   })
 
   it('keeps a non-ready repo navigable without actions or session requests', async () => {
diff --git a/frontend/src/components/navigation/DesktopSidebar.test.tsx b/frontend/src/components/navigation/DesktopSidebar.test.tsx
index 535a9aa12..d5d17fb2a 100644
--- a/frontend/src/components/navigation/DesktopSidebar.test.tsx
+++ b/frontend/src/components/navigation/DesktopSidebar.test.tsx
@@ -11,6 +11,10 @@ import * as useAuthModule from '@/hooks/useAuth'
 vi.mock('@/hooks/useDesktop')
 vi.mock('@/hooks/useSidebarCollapsed')
 vi.mock('@/hooks/useAuth')
+vi.mock('@/hooks/useOpenCodeServers', () => ({
+  useOpenCodeServers: () => ({ servers: [], isLoading: false }),
+  useOpenCodeServerStatuses: () => ({ statuses: [], statusById: {}, isLoading: false }),
+}))
 vi.mock('@/components/navigation/DesktopSessionTree', () => ({
   DesktopSessionTree: () => <div data-testid="session-tree" />,
 }))
@@ -245,6 +249,20 @@ describe('DesktopSidebar', () => {
     expect(screen.getByText('Settings')).toBeInTheDocument()
     expect(screen.getByText('Logout')).toBeInTheDocument()
   })
+
+  it('hides the Servers group when no linked servers exist', () => {
+    vi.spyOn(useDesktopModule, 'useDesktop').mockReturnValue(true)
+    vi.spyOn(useSidebarCollapsedModule, 'useSidebarCollapsed').mockReturnValue([false, vi.fn()])
+    vi.spyOn(useAuthModule, 'useAuth').mockReturnValue({
+      isAuthenticated: true,
+      isLoading: false,
+      logout: vi.fn(),
+    } as any)
+
+    render(<DesktopSidebar />, { wrapper: createWrapper(['/']) })
+
+    expect(screen.queryByText('Servers')).toBeNull()
+  })
   it('renders home, repos and account items and no session tree when collapsed', () => {
     vi.spyOn(useDesktopModule, 'useDesktop').mockReturnValue(true)
     vi.spyOn(useSidebarCollapsedModule, 'useSidebarCollapsed').mockReturnValue([true, vi.fn()])
diff --git a/frontend/src/components/navigation/DesktopSidebar.tsx b/frontend/src/components/navigation/DesktopSidebar.tsx
index e000ef239..ed9bc907d 100644
--- a/frontend/src/components/navigation/DesktopSidebar.tsx
+++ b/frontend/src/components/navigation/DesktopSidebar.tsx
@@ -9,6 +9,7 @@ import { useOpenNavItem } from '@/hooks/useOpenNavItem'
 import { buildNavModel, type MoreDrawerItem, type NavPrimaryCta } from '@/components/navigation/moreDrawerItems'
 import { RepoQuickSwitchSheet } from '@/components/navigation/RepoQuickSwitchSheet'
 import { DesktopSessionTree } from '@/components/navigation/DesktopSessionTree'
+import { LinkedServersNav } from '@/components/navigation/LinkedServersNav'
 import {
   Sidebar,
   SidebarSection,
@@ -102,6 +103,8 @@ export function DesktopSidebar() {
           </div>
         ) : (
           <>
+            <LinkedServersNav />
+
             <section aria-label="Sessions" className="flex min-h-0 flex-1 flex-col border-t border-border">
               <h2 className="px-3 py-1.5 text-xs font-medium uppercase tracking-wider text-muted-foreground">Sessions</h2>
               <DesktopSessionTree />
diff --git a/frontend/src/components/navigation/LinkedServersNav.test.tsx b/frontend/src/components/navigation/LinkedServersNav.test.tsx
new file mode 100644
index 000000000..caaf40e87
--- /dev/null
+++ b/frontend/src/components/navigation/LinkedServersNav.test.tsx
@@ -0,0 +1,78 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { render, screen } from '@testing-library/react'
+import { MemoryRouter } from 'react-router-dom'
+import { LinkedServersNav } from './LinkedServersNav'
+
+const mocks = vi.hoisted(() => ({
+  useOpenCodeServers: vi.fn(),
+  useOpenCodeServerStatuses: vi.fn(),
+}))
+
+vi.mock('@/hooks/useOpenCodeServers', () => ({
+  useOpenCodeServers: mocks.useOpenCodeServers,
+  useOpenCodeServerStatuses: mocks.useOpenCodeServerStatuses,
+}))
+
+const kitchen = {
+  id: 'srv_kitchen',
+  name: 'Kitchen',
+  baseUrl: 'https://kitchen.example.com',
+  username: 'opencode',
+  enabled: true,
+  hasPassword: true,
+  createdAt: 1,
+  updatedAt: 2,
+}
+
+const office = { ...kitchen, id: 'srv_office', name: 'Office' }
+
+function renderNav(pathname = '/') {
+  return render(
+    <MemoryRouter initialEntries={[pathname]}>
+      <LinkedServersNav />
+    </MemoryRouter>,
+  )
+}
+
+describe('LinkedServersNav', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mocks.useOpenCodeServers.mockReturnValue({ servers: [], isLoading: false })
+    mocks.useOpenCodeServerStatuses.mockReturnValue({
+      statuses: [],
+      statusById: { srv_kitchen: { serverId: 'srv_kitchen', connected: true, version: null, error: null } },
+      isLoading: false,
+    })
+  })
+
+  it('renders nothing when no linked servers exist', () => {
+    const { container } = renderNav()
+
+    expect(container).toBeEmptyDOMElement()
+    expect(screen.queryByText('Servers')).not.toBeInTheDocument()
+  })
+
+  it('lists enabled servers with a link and connection dot', () => {
+    mocks.useOpenCodeServers.mockReturnValue({ servers: [kitchen, office], isLoading: false })
+
+    renderNav()
+
+    expect(screen.getByText('Servers')).toBeInTheDocument()
+    expect(screen.getByRole('link', { name: /Kitchen/ })).toHaveAttribute('href', '/servers/srv_kitchen')
+    expect(screen.getByRole('link', { name: /Office/ })).toHaveAttribute('href', '/servers/srv_office')
+    expect(screen.getByRole('img', { name: 'Connected' })).toBeInTheDocument()
+    expect(screen.getByRole('img', { name: 'Disconnected' })).toBeInTheDocument()
+  })
+
+  it('hides disabled servers', () => {
+    mocks.useOpenCodeServers.mockReturnValue({
+      servers: [kitchen, { ...office, enabled: false }],
+      isLoading: false,
+    })
+
+    renderNav()
+
+    expect(screen.getByRole('link', { name: /Kitchen/ })).toBeInTheDocument()
+    expect(screen.queryByRole('link', { name: /Office/ })).not.toBeInTheDocument()
+  })
+})
diff --git a/frontend/src/components/navigation/LinkedServersNav.tsx b/frontend/src/components/navigation/LinkedServersNav.tsx
new file mode 100644
index 000000000..77436ed61
--- /dev/null
+++ b/frontend/src/components/navigation/LinkedServersNav.tsx
@@ -0,0 +1,51 @@
+import { Link, useLocation } from 'react-router-dom'
+import { Server } from 'lucide-react'
+import { useOpenCodeServers, useOpenCodeServerStatuses } from '@/hooks/useOpenCodeServers'
+import { SidebarSection } from '@/components/ui/sidebar'
+import { getServerPath } from '@/lib/navigation'
+import { cn } from '@/lib/utils'
+
+export function LinkedServersNav() {
+  const location = useLocation()
+  const { servers, isLoading } = useOpenCodeServers()
+  const { statusById } = useOpenCodeServerStatuses()
+  const enabledServers = servers.filter((server) => server.enabled)
+
+  if (isLoading || enabledServers.length === 0) {
+    return null
+  }
+
+  return (
+    <SidebarSection label="Servers" collapsed={false}>
+      {enabledServers.map((server) => {
+        const path = getServerPath(server.id)
+        const active = location.pathname === path || location.pathname.startsWith(`${path}/`)
+        const connected = statusById[server.id]?.connected ?? false
+
+        return (
+          <Link
+            key={server.id}
+            to={path}
+            className={cn(
+              'flex items-center gap-3 rounded-md p-2.5 text-sm transition-colors duration-150',
+              'focus:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background',
+              active ? 'bg-accent text-accent-foreground' : 'text-foreground hover:bg-accent/50',
+            )}
+          >
+            <Server className="h-5 w-5 shrink-0" />
+            <span className="min-w-0 flex-1 truncate">{server.name}</span>
+            <span
+              role="img"
+              aria-label={connected ? 'Connected' : 'Disconnected'}
+              title={connected ? 'Connected' : 'Disconnected'}
+              className={cn(
+                'h-2 w-2 shrink-0 rounded-full',
+                connected ? 'bg-success' : 'bg-muted-foreground/40',
+              )}
+            />
+          </Link>
+        )
+      })}
+    </SidebarSection>
+  )
+}
diff --git a/frontend/src/components/navigation/MobileSheetHost.test.tsx b/frontend/src/components/navigation/MobileSheetHost.test.tsx
index 1c6dc5699..1d425d251 100644
--- a/frontend/src/components/navigation/MobileSheetHost.test.tsx
+++ b/frontend/src/components/navigation/MobileSheetHost.test.tsx
@@ -89,6 +89,20 @@ describe('MobileSheetHost', () => {
     expect(sheet.getAttribute('data-repo-name')).toBe('Workspace Root')
   })
 
+  it('hides the FileBrowserSheet on a linked-server route', () => {
+    vi.mocked(useMobileTabBar).mockReturnValue({
+      openSheet: 'files',
+      open: vi.fn(),
+      close: vi.fn(),
+    })
+    render(
+      <MemoryRouter initialEntries={['/servers/srv_kitchen/sessions/ses_remote?mobileTab=files']}>
+        <MobileSheetHost />
+      </MemoryRouter>,
+    )
+    expect(screen.queryByTestId('file-browser-sheet')).not.toBeInTheDocument()
+  })
+
   it('renders NotificationsSheet when mobileTab=notifications', () => {
     vi.mocked(useMobileTabBar).mockReturnValue({
       openSheet: 'notifications',
diff --git a/frontend/src/components/navigation/MobileSheetHost.tsx b/frontend/src/components/navigation/MobileSheetHost.tsx
index 0a7232d83..4134cd7f0 100644
--- a/frontend/src/components/navigation/MobileSheetHost.tsx
+++ b/frontend/src/components/navigation/MobileSheetHost.tsx
@@ -4,17 +4,19 @@ import { FileBrowserSheet } from '@/components/file-browser/FileBrowserSheet'
 import { RepoQuickSwitchSheet } from '@/components/navigation/RepoQuickSwitchSheet'
 import { NotificationsSheet } from '@/components/navigation/NotificationsSheet'
 import { MoreDrawer } from '@/components/navigation/MoreDrawer'
+import { isLocalOpenCodeServer, useRouteOpenCodeServerId } from '@/contexts/OpenCodeServerContext'
 
 export function MobileSheetHost() {
   const isMobile = useMobile()
   const { openSheet, close } = useMobileTabBar()
+  const isRemoteRoute = !isLocalOpenCodeServer(useRouteOpenCodeServerId())
 
   if (!isMobile) return null
 
   return (
     <>
       <RepoQuickSwitchSheet isOpen={openSheet === 'repos'} onClose={close} />
-      {openSheet === 'files' && (
+      {openSheet === 'files' && !isRemoteRoute && (
         <FileBrowserSheet
           isOpen
           onClose={close}
diff --git a/frontend/src/components/navigation/MoreDrawer.test.tsx b/frontend/src/components/navigation/MoreDrawer.test.tsx
index a402a49e9..1e40ef2e0 100644
--- a/frontend/src/components/navigation/MoreDrawer.test.tsx
+++ b/frontend/src/components/navigation/MoreDrawer.test.tsx
@@ -401,6 +401,31 @@ describe('MoreDrawer', () => {
     expect(handleClose).not.toHaveBeenCalled()
   })
 
+  it('offers only the remote-capable project items on a linked-server route', () => {
+    mockAuth()
+    mockServerHealth()
+    setActivityGroups({ recent: [createActiveWorkItem()] })
+    renderMoreDrawer({
+      initialEntry: '/servers/srv_kitchen/sessions/ses_remote',
+      routePath: '/servers/:serverId/sessions/:sessionId',
+    })
+
+    expect(screen.getByText('Home')).toBeInTheDocument()
+    expect(screen.getByText('MCP')).toBeInTheDocument()
+    expect(screen.getByText('Skills')).toBeInTheDocument()
+    expect(screen.getByText('Settings')).toBeInTheDocument()
+    expect(screen.getByText('Logout')).toBeInTheDocument()
+    expect(screen.queryByText('Files')).not.toBeInTheDocument()
+    expect(screen.queryByText('Source Control')).not.toBeInTheDocument()
+    expect(screen.queryByText('Terminal')).not.toBeInTheDocument()
+    expect(screen.queryByText('Preview')).not.toBeInTheDocument()
+    expect(screen.queryByText('Schedules')).not.toBeInTheDocument()
+    expect(screen.queryByText('Reset Permissions')).not.toBeInTheDocument()
+    expect(screen.queryByText('Repos')).not.toBeInTheDocument()
+    expect(screen.queryByRole('button', { name: 'Assistant' })).not.toBeInTheDocument()
+    expect(screen.queryByRole('heading', { name: 'Activity' })).not.toBeInTheDocument()
+  })
+
   it('shows unread reports and marks them all read', () => {
     const markAllReportsViewed = vi.fn()
     mockAuth()
diff --git a/frontend/src/components/navigation/MoreDrawer.tsx b/frontend/src/components/navigation/MoreDrawer.tsx
index 48f1c26f1..83582333c 100644
--- a/frontend/src/components/navigation/MoreDrawer.tsx
+++ b/frontend/src/components/navigation/MoreDrawer.tsx
@@ -11,11 +11,12 @@ import { SideDrawer, SideDrawerContent } from '@/components/ui/side-drawer'
 import { CompactActivityList } from '@/components/activity/CompactActivityList'
 import { ScheduleReportsList } from '@/components/notifications/ScheduleReportsBell'
 import { useMarkAllScheduleRunsViewed, useUnreadScheduleRuns } from '@/hooks/useSchedules'
-import { buildMoreItems, buildNavModel, isSessionDetailPath, type MoreDrawerItem } from './moreDrawerItems'
+import { buildMoreItems, buildNavModel, isManagerOnlyNavItem, isSessionDetailPath, type MoreDrawerItem } from './moreDrawerItems'
 import { useSwipeBack } from '@/hooks/useMobile'
 import { cn, getRepoDisplayName } from '@/lib/utils'
 import { getPathWithReturnTo, isAssistantPath } from '@/lib/navigation'
 import { useMobileTabBar } from '@/hooks/useMobileTabBar'
+import { isLocalOpenCodeServer, useRouteOpenCodeServerId } from '@/contexts/OpenCodeServerContext'
 
 interface MoreDrawerProps {
   isOpen: boolean
@@ -78,6 +79,7 @@ export function MoreDrawer({ isOpen, onClose }: MoreDrawerProps) {
   const isSessionDetail = isSessionDetailPath(location.pathname)
   const isAssistantRoute = isAssistantPath(location.pathname)
   const isAssistantSession = isSessionDetail && searchParams.get('assistant') === '1'
+  const isRemoteRoute = !isLocalOpenCodeServer(useRouteOpenCodeServerId())
   const { open: openMobileSheet } = useMobileTabBar()
   const { data: unreadReports } = useUnreadScheduleRuns()
   const markAllReportsViewed = useMarkAllScheduleRunsViewed()
@@ -141,11 +143,13 @@ export function MoreDrawer({ isOpen, onClose }: MoreDrawerProps) {
     }
   }
 
-  const items = buildMoreItems(location.pathname)
+  const items = buildMoreItems(location.pathname).filter(
+    (item) => !isRemoteRoute || !isManagerOnlyNavItem(item),
+  )
   const itemsInGroup = (keys: ReadonlySet<string>) => items.filter((item) => keys.has(item.key))
   const groupedKeys = new Set([...ACCOUNT_ITEM_KEYS, ...ITEM_GROUPS.flatMap(({ keys }) => [...keys])])
   const navigationItems = items.filter((item) => !groupedKeys.has(item.key))
-  const assistantCta = isSessionDetail && !isAssistantSession
+  const assistantCta = isSessionDetail && !isAssistantSession && !isRemoteRoute
     ? buildNavModel(location.pathname).primary.find((cta) => cta.key === 'assistant')
     : undefined
 
@@ -201,11 +205,11 @@ export function MoreDrawer({ isOpen, onClose }: MoreDrawerProps) {
               />
             </div>
           )}
-          {isOpen && (
+          {isOpen && !isRemoteRoute && (
             <CompactActivityList onNavigate={(path) => navigate(path)} />
           )}
           <MenuSection>
-            {isSessionDetail && (
+            {isSessionDetail && !isRemoteRoute && (
               <MenuRow icon={FolderGit2} label="Repos" onClick={() => openMobileSheet('repos')} trailing />
             )}
             {assistantCta?.to && (
diff --git a/frontend/src/components/navigation/ToolSidePanel.test.tsx b/frontend/src/components/navigation/ToolSidePanel.test.tsx
index 1ff5144d2..6f0a26866 100644
--- a/frontend/src/components/navigation/ToolSidePanel.test.tsx
+++ b/frontend/src/components/navigation/ToolSidePanel.test.tsx
@@ -149,6 +149,23 @@ function HomeHarness() {
   )
 }
 
+function RemoteHarness() {
+  const panel = useToolPanel(true)
+  return (
+    <>
+      <ToolSidePanel
+        panel={panel}
+        repoId={0}
+        sessionId="ses_remote"
+        directory="/home/me/app"
+        repoDirectory="/home/me/app"
+        filesBasePath={undefined}
+      />
+      <LocationProbe />
+    </>
+  )
+}
+
 beforeEach(() => {
   vi.clearAllMocks()
   activityMocks.useActiveWorkCounts.mockReturnValue({ needsInput: 0, running: 0 })
@@ -330,6 +347,25 @@ describe('ToolSidePanel', () => {
     expect(buttons[0]).toHaveAccessibleName('Activity')
   })
 
+  it('shows only the remote-capable tools on a linked-server route', async () => {
+    const user = userEvent.setup()
+    render(
+      <MemoryRouter initialEntries={['/servers/srv_kitchen/sessions/ses_remote']}>
+        <RemoteHarness />
+      </MemoryRouter>,
+    )
+
+    const rail = screen.getByRole('navigation', { name: 'Tools' })
+    expect(
+      within(rail)
+        .getAllByRole('button')
+        .map((button) => button.getAttribute('aria-label') ?? button.textContent?.trim()),
+    ).toEqual(['Activity', 'MCP', 'Skills'])
+
+    await user.click(screen.getByRole('button', { name: 'MCP' }))
+    expect(await screen.findByText('mcp-tool')).toBeInTheDocument()
+  })
+
   it('opens the Activity panel with rows and the window label when clicked', async () => {
     const user = userEvent.setup()
     setActivityGroups([createActivityItem('other', 'Other Session', 2, 'Beta')])
diff --git a/frontend/src/components/navigation/ToolSidePanel.tsx b/frontend/src/components/navigation/ToolSidePanel.tsx
index ed36232da..e65d0eb5c 100644
--- a/frontend/src/components/navigation/ToolSidePanel.tsx
+++ b/frontend/src/components/navigation/ToolSidePanel.tsx
@@ -31,11 +31,14 @@ import { formatActivityWindow } from '@/lib/activeWork'
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip'
 import { restoreOverlayFocus } from '@/lib/overlayFocus'
 import { cn } from '@/lib/utils'
+import { isLocalOpenCodeServer, useRouteOpenCodeServerId } from '@/contexts/OpenCodeServerContext'
 
 const PANEL_WIDTH_CLASSES: Partial<Record<PanelTool, string>> = {
   activity: 'w-80',
 }
 
+const REMOTE_TOOL_KEYS: ReadonlySet<string> = new Set(['activity', 'mcp', 'skills'])
+
 function ActivityWindowLabel() {
   const minutes = useActivityWindowMinutes()
   return (
@@ -157,6 +160,7 @@ export function ToolSidePanel({
   const { activeTool, toggleTool, closePanel } = panel
   const location = useLocation()
   const openNavItem = useOpenNavItem()
+  const isRemoteRoute = !isLocalOpenCodeServer(useRouteOpenCodeServerId())
   const railRef = useRef<HTMLElement>(null)
   const previousActiveToolRef = useRef(activeTool)
 
@@ -173,6 +177,7 @@ export function ToolSidePanel({
   const panelTools: Array<{ item: MoreDrawerItem; tool: PanelTool }> = []
   const actionItems: MoreDrawerItem[] = []
   for (const item of buildToolItems(location.pathname)) {
+    if (isRemoteRoute && !REMOTE_TOOL_KEYS.has(item.key)) continue
     const tool = toolKeyOf(item)
     if (isPanelTool(tool)) panelTools.push({ item, tool })
     else actionItems.push(item)
diff --git a/frontend/src/components/navigation/moreDrawerItems.test.ts b/frontend/src/components/navigation/moreDrawerItems.test.ts
index 8d759616b..bb03bc405 100644
--- a/frontend/src/components/navigation/moreDrawerItems.test.ts
+++ b/frontend/src/components/navigation/moreDrawerItems.test.ts
@@ -62,6 +62,11 @@ describe('buildMoreItems', () => {
     expect(items[12].key).toBe('logout')
   })
 
+  it('returns only the server tools a linked server can serve for /servers/:id/sessions/:sid', () => {
+    const items = buildMoreItems('/servers/srv_kitchen/sessions/abc')
+    expect(items.map((item) => item.key)).toEqual(['home', 'mcp', 'skills', 'settings', 'logout'])
+  })
+
   it('omits the Actions item for an Assistant session', () => {
     const items = buildMoreItems('/repos/0/sessions/abc')
     expect(items).toHaveLength(12)
@@ -164,6 +169,14 @@ describe('buildToolItems', () => {
     ])
   })
 
+  it('returns the linked-server session tools for the tool rail', () => {
+    expect(buildToolItems('/servers/srv_kitchen/sessions/abc').map((item) => item.key)).toEqual([
+      'activity',
+      'mcp',
+      'skills',
+    ])
+  })
+
   it('returns the home route tools', () => {
     expect(buildToolItems('/').map((item) => item.key)).toEqual(['activity', 'all-schedules', 'files'])
   })
diff --git a/frontend/src/components/navigation/moreDrawerItems.ts b/frontend/src/components/navigation/moreDrawerItems.ts
index d142cc192..9871bfd71 100644
--- a/frontend/src/components/navigation/moreDrawerItems.ts
+++ b/frontend/src/components/navigation/moreDrawerItems.ts
@@ -48,6 +48,7 @@ function getBaseItems(): MoreDrawerItem[] {
 }
 
 const SESSION_DETAIL_PATH = /^\/repos\/(\d+)\/sessions\/[^/]+$/
+const SERVER_SESSION_DETAIL_PATH = /^\/servers\/[^/]+\/sessions\/[^/]+$/
 
 export function isSessionDetailPath(pathname: string): boolean {
   return SESSION_DETAIL_PATH.test(pathname)
@@ -55,6 +56,23 @@ export function isSessionDetailPath(pathname: string): boolean {
 
 const NON_TOOL_ITEM_KEYS = new Set(['home', 'settings', 'logout'])
 
+const MANAGER_ONLY_ITEM_KEYS: ReadonlySet<string> = new Set([
+  'files',
+  'source-control',
+  'terminal',
+  'preview',
+  'walkthrough',
+  'actions',
+  'reset-permissions',
+  'schedules',
+  'all-schedules',
+])
+
+/** True for an item that opens a Manager feature a linked OpenCode server cannot serve. */
+export function isManagerOnlyNavItem(item: MoreDrawerItem): boolean {
+  return MANAGER_ONLY_ITEM_KEYS.has(item.key)
+}
+
 /** Route-scoped tool items, shown in the desktop tool rail instead of the sidebar. */
 export function buildToolItems(pathname: string): MoreDrawerItem[] {
   const routeItems = buildNavModel(pathname).items.filter((item) => !NON_TOOL_ITEM_KEYS.has(item.key))
@@ -69,6 +87,17 @@ export function toolKeyOf(item: MoreDrawerItem): string | null {
 function buildRouteNavModel(pathname: string): NavModel {
   const baseItems = getBaseItems()
 
+  if (SERVER_SESSION_DETAIL_PATH.test(pathname)) {
+    return {
+      primary: [getAssistantNavItem()],
+      items: [
+        { key: 'mcp', label: 'MCP', icon: Plug, dialog: 'mcp' },
+        { key: 'skills', label: 'Skills', icon: Sparkles, dialog: 'skills' },
+        ...baseItems,
+      ],
+    }
+  }
+
   const repoDetailMatch = /^\/repos\/(\d+)$/.exec(pathname)
   if (repoDetailMatch) {
     const id = repoDetailMatch[1]
diff --git a/frontend/src/components/notifications/PendingActionsGroup.tsx b/frontend/src/components/notifications/PendingActionsGroup.tsx
index 529f98c9f..b1b1b0f81 100644
--- a/frontend/src/components/notifications/PendingActionsGroup.tsx
+++ b/frontend/src/components/notifications/PendingActionsGroup.tsx
@@ -3,13 +3,17 @@ import { PendingActionBadge } from '@/components/ui/pending-action-badge'
 import { ScheduleReportsBell } from '@/components/notifications/ScheduleReportsBell'
 import { usePermissions, useForms } from '@/contexts/EventContext'
 
-export function PendingActionsGroup() {
+interface PendingActionsGroupProps {
+  showScheduleReports?: boolean
+}
+
+export function PendingActionsGroup({ showScheduleReports = true }: PendingActionsGroupProps) {
   const { pendingCount: permissionCount, setShowDialog, navigateToCurrent: navigateToPermission } = usePermissions()
   const { pendingCount: formCount, navigateToCurrent } = useForms()
 
   return (
     <>
-      <ScheduleReportsBell />
+      {showScheduleReports ? <ScheduleReportsBell /> : null}
       <PendingActionBadge
         count={permissionCount}
         icon={Bell}
diff --git a/frontend/src/components/repo/RepoMcpDialog.test.tsx b/frontend/src/components/repo/RepoMcpDialog.test.tsx
new file mode 100644
index 000000000..a0f21027f
--- /dev/null
+++ b/frontend/src/components/repo/RepoMcpDialog.test.tsx
@@ -0,0 +1,103 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { render, screen, waitFor } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import type { ReactNode } from 'react'
+import { RepoMcpContent } from './RepoMcpDialog'
+import { OpenCodeServerProvider } from '@/contexts/OpenCodeServerContext'
+
+const mocks = vi.hoisted(() => ({
+  getStatus: vi.fn(),
+  connect: vi.fn(),
+  disconnect: vi.fn(),
+  removeAuth: vi.fn(),
+  startAuth: vi.fn(),
+}))
+
+vi.mock('@/api/mcp', () => ({ mcpApi: mocks }))
+
+vi.mock('@/components/settings/McpOAuthDialog', () => ({
+  McpOAuthDialog: () => <div data-testid="mcp-oauth-dialog" />,
+}))
+
+vi.mock('@/lib/toast', () => ({
+  showToast: { success: vi.fn(), error: vi.fn(), info: vi.fn(), warning: vi.fn() },
+}))
+
+function renderContent(serverId: string) {
+  const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+  const wrapper = ({ children }: { children: ReactNode }) => (
+    <QueryClientProvider client={queryClient}>
+      <OpenCodeServerProvider serverId={serverId}>{children}</OpenCodeServerProvider>
+    </QueryClientProvider>
+  )
+  return render(<RepoMcpContent open directory="/home/me/app" />, { wrapper })
+}
+
+describe('RepoMcpContent', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('reads MCP status from the linked server for the session directory', async () => {
+    mocks.getStatus.mockResolvedValue({
+      server: { status: 'connected', integrationID: 'int_1' },
+    })
+
+    renderContent('srv_kitchen')
+
+    await waitFor(() => {
+      expect(mocks.getStatus).toHaveBeenCalledWith('/home/me/app', 'srv_kitchen')
+    })
+  })
+
+  it('connects and disconnects MCP servers against the linked server', async () => {
+    mocks.getStatus.mockResolvedValue({ server: { status: 'connected' } })
+    mocks.disconnect.mockResolvedValue(undefined)
+    const user = userEvent.setup()
+
+    renderContent('srv_kitchen')
+
+    const toggle = await screen.findByRole('switch')
+    await user.click(toggle)
+
+    await waitFor(() => {
+      expect(mocks.disconnect).toHaveBeenCalledWith('server', '/home/me/app', 'srv_kitchen')
+    })
+  })
+
+  it('hides every Manager OAuth action for a linked server', async () => {
+    mocks.getStatus.mockResolvedValue({
+      server: { status: 'connected', integrationID: 'int_1' },
+      authServer: { status: 'needs_auth', error: 'auth required', integrationID: 'int_2' },
+    })
+
+    renderContent('srv_kitchen')
+
+    await screen.findByText('Auth Required')
+
+    expect(screen.queryByTitle('Click for options')).not.toBeInTheDocument()
+    expect(screen.queryByRole('button', { name: 'Auth' })).not.toBeInTheDocument()
+    expect(screen.queryByText('Re-authenticate')).not.toBeInTheDocument()
+    expect(screen.queryByText('Remove Auth')).not.toBeInTheDocument()
+    expect(screen.queryByTestId('mcp-oauth-dialog')).not.toBeInTheDocument()
+    expect(mocks.removeAuth).not.toHaveBeenCalled()
+    expect(mocks.startAuth).not.toHaveBeenCalled()
+  })
+
+  it('keeps the Manager OAuth actions for the local server', async () => {
+    mocks.getStatus.mockResolvedValue({
+      server: { status: 'connected', integrationID: 'int_1' },
+    })
+    const user = userEvent.setup()
+
+    renderContent('local')
+
+    expect(await screen.findByTestId('mcp-oauth-dialog')).toBeInTheDocument()
+
+    await user.click(screen.getByTitle('Click for options'))
+
+    expect(await screen.findByText('Re-authenticate')).toBeInTheDocument()
+    expect(screen.getByText('Remove Auth')).toBeInTheDocument()
+  })
+})
diff --git a/frontend/src/components/repo/RepoMcpDialog.tsx b/frontend/src/components/repo/RepoMcpDialog.tsx
index c0e2405d9..316f022e7 100644
--- a/frontend/src/components/repo/RepoMcpDialog.tsx
+++ b/frontend/src/components/repo/RepoMcpDialog.tsx
@@ -4,6 +4,7 @@ import { RepoMcpServerList } from './RepoMcpServerList'
 import { DeleteDialog } from '@/components/ui/delete-dialog'
 import { McpOAuthDialog } from '@/components/settings/McpOAuthDialog'
 import { mcpApi, type McpStatus, type McpAuthStartResponse } from '@/api/mcp'
+import { isLocalOpenCodeServer, useOpenCodeServerId } from '@/contexts/OpenCodeServerContext'
 import { useMutation, useQueryClient } from '@tanstack/react-query'
 import { invalidateSessionCaches } from '@/lib/queryInvalidation'
 import { showToast } from '@/lib/toast'
@@ -21,6 +22,8 @@ interface RepoMcpContentProps {
 }
 
 export function RepoMcpContent({ open, directory }: RepoMcpContentProps) {
+  const openCodeServerId = useOpenCodeServerId()
+  const isRemoteServer = !isLocalOpenCodeServer(openCodeServerId)
   const queryClient = useQueryClient()
   const [localStatus, setLocalStatus] = useState<Record<string, McpStatus>>({})
   const [isLoadingStatus, setIsLoadingStatus] = useState(false)
@@ -33,19 +36,19 @@ export function RepoMcpContent({ open, directory }: RepoMcpContentProps) {
   const fetchStatus = useCallback(async () => {
     setIsLoadingStatus(true)
     try {
-      setLocalStatus(await mcpApi.getStatus(directory))
+      setLocalStatus(await mcpApi.getStatus(directory, openCodeServerId))
       setHasFetchedStatus(true)
     } finally {
       setIsLoadingStatus(false)
     }
-  }, [directory])
+  }, [directory, openCodeServerId])
 
   const toggleMutation = useMutation({
     mutationFn: async ({ serverId, enable }: { serverId: string; enable: boolean }) => {
       if (enable) {
-        await mcpApi.connect(serverId, directory)
+        await mcpApi.connect(serverId, directory, openCodeServerId)
       } else {
-        await mcpApi.disconnect(serverId, directory)
+        await mcpApi.disconnect(serverId, directory, openCodeServerId)
       }
     },
     onSuccess: async () => {
@@ -80,7 +83,7 @@ export function RepoMcpContent({ open, directory }: RepoMcpContentProps) {
 
   const handleOAuthCheckStatus = async (): Promise<boolean> => {
     if (!authDialogServerId) return false
-    const status = await mcpApi.getStatus(directory)
+    const status = await mcpApi.getStatus(directory, openCodeServerId)
     if (status[authDialogServerId]?.status === 'connected') {
       setLocalStatus(status)
       return true
@@ -106,36 +109,41 @@ export function RepoMcpContent({ open, directory }: RepoMcpContentProps) {
         serverIds={serverIds}
         isLoadingStatus={isLoadingStatus}
         localStatus={localStatus}
+        oauthAvailable={!isRemoteServer}
         toggleMutation={toggleMutation}
         removeAuthMutation={removeAuthMutation}
         onAuthClick={setAuthDialogServerId}
         onRemoveAuthClick={setRemoveAuthConfirmServer}
       />
 
-      <DeleteDialog
-        open={!!removeAuthConfirmServer}
-        onOpenChange={() => setRemoveAuthConfirmServer(null)}
-        onConfirm={() => {
-          if (removeAuthConfirmServer) {
-            removeAuthMutation.mutate(removeAuthConfirmServer)
-          }
-        }}
-        onCancel={() => setRemoveAuthConfirmServer(null)}
-        title="Remove Authentication"
-        description="This will remove the OAuth credentials for this MCP server at this location. You will need to re-authenticate to use this server here again."
-        itemName={removeAuthConfirmServer ? formatMcpServerName(removeAuthConfirmServer) : ''}
-        isDeleting={removeAuthMutation.isPending}
-      />
-
-      <McpOAuthDialog
-        open={!!authDialogServerId}
-        onOpenChange={(o) => !o && setAuthDialogServerId(null)}
-        serverName={authDialogServerId || ''}
-        onStartAuth={handleOAuthStartAuth}
-        onCheckStatus={handleOAuthCheckStatus}
-        onSuccess={handleOAuthSuccess}
-        directory={directory}
-      />
+      {!isRemoteServer && (
+        <DeleteDialog
+          open={!!removeAuthConfirmServer}
+          onOpenChange={() => setRemoveAuthConfirmServer(null)}
+          onConfirm={() => {
+            if (removeAuthConfirmServer) {
+              removeAuthMutation.mutate(removeAuthConfirmServer)
+            }
+          }}
+          onCancel={() => setRemoveAuthConfirmServer(null)}
+          title="Remove Authentication"
+          description="This will remove the OAuth credentials for this MCP server at this location. You will need to re-authenticate to use this server here again."
+          itemName={removeAuthConfirmServer ? formatMcpServerName(removeAuthConfirmServer) : ''}
+          isDeleting={removeAuthMutation.isPending}
+        />
+      )}
+
+      {!isRemoteServer && (
+        <McpOAuthDialog
+          open={!!authDialogServerId}
+          onOpenChange={(o) => !o && setAuthDialogServerId(null)}
+          serverName={authDialogServerId || ''}
+          onStartAuth={handleOAuthStartAuth}
+          onCheckStatus={handleOAuthCheckStatus}
+          onSuccess={handleOAuthSuccess}
+          directory={directory}
+        />
+      )}
     </div>
   )
 }
diff --git a/frontend/src/components/repo/RepoMcpServerList.tsx b/frontend/src/components/repo/RepoMcpServerList.tsx
index 3edaa5288..bd5669142 100644
--- a/frontend/src/components/repo/RepoMcpServerList.tsx
+++ b/frontend/src/components/repo/RepoMcpServerList.tsx
@@ -12,6 +12,7 @@ interface RepoMcpServerListProps {
   serverIds: string[]
   isLoadingStatus: boolean
   localStatus: Record<string, McpStatus>
+  oauthAvailable: boolean
   toggleMutation: {
     mutate: (variables: { serverId: string; enable: boolean }) => void
     isPending: boolean
@@ -29,6 +30,7 @@ export function RepoMcpServerList({
   serverIds,
   isLoadingStatus,
   localStatus,
+  oauthAvailable,
   toggleMutation,
   removeAuthMutation,
   onAuthClick,
@@ -56,7 +58,8 @@ export function RepoMcpServerList({
             const failed = status?.status === 'failed'
             const isOAuthServer = !!status?.integrationID
             const connectedWithOAuth = isOAuthServer && isConnected
-            const showAuthButton = needsAuth || (isOAuthServer && failed)
+            const showAuthButton = oauthAvailable && (needsAuth || (isOAuthServer && failed))
+            const showOAuthMenu = oauthAvailable && (showAuthButton || connectedWithOAuth)
 
             return (
               <div
@@ -68,7 +71,7 @@ export function RepoMcpServerList({
                     <p className="text-sm font-medium truncate">
                       {formatMcpServerName(serverId)}
                     </p>
-                    {(showAuthButton || connectedWithOAuth) ? (
+                    {showOAuthMenu ? (
                       <DropdownMenu>
                         <DropdownMenuTrigger asChild>
                           <button 
diff --git a/frontend/src/components/repo/RepoSkillsDialog.test.tsx b/frontend/src/components/repo/RepoSkillsDialog.test.tsx
index dfd4d5fc3..96c6b68fc 100644
--- a/frontend/src/components/repo/RepoSkillsDialog.test.tsx
+++ b/frontend/src/components/repo/RepoSkillsDialog.test.tsx
@@ -4,10 +4,12 @@ import userEvent from '@testing-library/user-event'
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
 import type { ReactNode } from 'react'
 import { RepoSkillsDialog } from './RepoSkillsDialog'
+import { OpenCodeServerProvider } from '@/contexts/OpenCodeServerContext'
 import type { SkillFileInfo } from '@opencode-manager/shared'
 
 const mocks = vi.hoisted(() => ({
   listManagedSkills: vi.fn(),
+  listSkills: vi.fn(),
   activateSkill: vi.fn(),
 }))
 
@@ -20,6 +22,7 @@ vi.mock('@/api/settings', () => ({
 
 vi.mock('@/api/opencode', () => ({
   activateSkill: mocks.activateSkill,
+  listSkills: mocks.listSkills,
 }))
 
 vi.mock('@/lib/toast', () => ({
@@ -224,7 +227,7 @@ describe('RepoSkillsDialog', () => {
 
       expect(onOpenChange).toHaveBeenCalledWith(false)
       expect(onSkillLoaded).toHaveBeenCalledWith(mockSkills[0])
-      expect(mocks.activateSkill).toHaveBeenCalledWith('test-session', 'test-skill')
+      expect(mocks.activateSkill).toHaveBeenCalledWith('test-session', 'test-skill', 'local')
     })
 
     it('shows toast error on activateSkill failure', async () => {
@@ -260,4 +263,70 @@ describe('RepoSkillsDialog', () => {
       expect(onOpenChange).toHaveBeenCalledWith(false)
     })
   })
+
+  describe('linked server', () => {
+    const remoteSkill = {
+      id: 'sk_1',
+      name: 'remote-skill',
+      description: 'From the server',
+      path: '/home/me/app/.opencode/skills/remote-skill/SKILL.md',
+      content: 'Remote body',
+    }
+
+    const renderRemote = (onSkillLoaded = vi.fn(), onOpenChange = vi.fn()) =>
+      render(
+        <OpenCodeServerProvider serverId="srv_kitchen">
+          <RepoSkillsDialog
+            open
+            onOpenChange={onOpenChange}
+            repoId={0}
+            sessionId="ses_remote"
+            directory="/home/me/app"
+            onSkillLoaded={onSkillLoaded}
+          />
+        </OpenCodeServerProvider>,
+        { wrapper: createWrapper() },
+      )
+
+    it('lists skills from the linked server and hides install and delete actions', async () => {
+      mocks.listSkills.mockResolvedValue([remoteSkill])
+
+      renderRemote()
+
+      await waitFor(() => {
+        expect(screen.getByText('remote-skill')).toBeInTheDocument()
+      })
+
+      expect(mocks.listSkills).toHaveBeenCalledWith('/home/me/app', 'srv_kitchen')
+      expect(mocks.listManagedSkills).not.toHaveBeenCalled()
+      expect(screen.queryByRole('button', { name: /install skill/i })).not.toBeInTheDocument()
+      expect(screen.queryByRole('button', { name: 'Actions for remote-skill' })).not.toBeInTheDocument()
+    })
+
+    it('loads a linked-server skill into the current session', async () => {
+      mocks.listSkills.mockResolvedValue([remoteSkill])
+      mocks.activateSkill.mockReturnValue(new Promise(() => {}))
+      const onSkillLoaded = vi.fn()
+      const onOpenChange = vi.fn()
+      const user = userEvent.setup()
+
+      renderRemote(onSkillLoaded, onOpenChange)
+
+      await waitFor(() => {
+        expect(screen.getByText('remote-skill')).toBeInTheDocument()
+      })
+
+      await user.click(screen.getByText('remote-skill').closest('[class*="cursor-pointer"]')!)
+
+      expect(mocks.activateSkill).toHaveBeenCalledWith('ses_remote', 'remote-skill', 'srv_kitchen')
+      expect(onSkillLoaded).toHaveBeenCalledWith({
+        name: 'remote-skill',
+        description: 'From the server',
+        body: 'Remote body',
+        scope: 'project',
+        location: '/home/me/app/.opencode/skills/remote-skill/SKILL.md',
+      })
+      expect(onOpenChange).toHaveBeenCalledWith(false)
+    })
+  })
 })
diff --git a/frontend/src/components/repo/RepoSkillsDialog.tsx b/frontend/src/components/repo/RepoSkillsDialog.tsx
index 98a58f594..6307a8aa7 100644
--- a/frontend/src/components/repo/RepoSkillsDialog.tsx
+++ b/frontend/src/components/repo/RepoSkillsDialog.tsx
@@ -1,4 +1,4 @@
-import { useState } from 'react'
+import { useMemo, useState } from 'react'
 import { useQuery, useQueryClient } from '@tanstack/react-query'
 import { Download } from 'lucide-react'
 import { Dialog, DialogContent, DialogHeader, DialogTitle } from '@/components/ui/dialog'
@@ -7,10 +7,24 @@ import { DeleteDialog } from '@/components/ui/delete-dialog'
 import { SkillLibraryList } from '@/components/skills/SkillLibraryList'
 import { SkillInstallDialog } from '@/components/settings/SkillInstallDialog'
 import { settingsApi } from '@/api/settings'
+import { listSkills } from '@/api/opencode'
 import { useLoadSkill } from '@/hooks/useOpenCode'
 import { useDeleteSkill } from '@/hooks/useDeleteSkill'
 import { invalidateSkillCaches } from '@/lib/queryInvalidation'
+import { isLocalOpenCodeServer, useOpenCodeServerId } from '@/contexts/OpenCodeServerContext'
+import { serverScopedKey } from '@/lib/serverScope'
 import type { SkillFileInfo } from '@opencode-manager/shared'
+import type { SkillInfo } from '@opencode-manager/shared/opencode'
+
+function toRemoteSkillFileInfo(skill: SkillInfo): SkillFileInfo {
+  return {
+    name: skill.name,
+    description: skill.description ?? '',
+    body: skill.content,
+    scope: 'project',
+    location: skill.path,
+  }
+}
 
 type RepoSkillsSessionProps =
   | { sessionId: string; directory?: string; onSkillLoaded?: (skill: SkillFileInfo) => void }
@@ -37,19 +51,42 @@ export function RepoSkillsContent({
   onDone,
 }: RepoSkillsContentProps) {
   const queryClient = useQueryClient()
+  const serverId = useOpenCodeServerId()
+  const isRemoteServer = !isLocalOpenCodeServer(serverId)
   const [installDialogOpen, setInstallDialogOpen] = useState(false)
   const { deleteSkill, setDeleteSkill, confirmDelete, isDeleting } = useDeleteSkill()
   const skillsQueryKey = directory ? ['settings', 'skills', 'directory', directory] : ['settings', 'skills', repoId]
 
-  const { isLoading, data, error } = useQuery({
+  const { isLoading: isLocalLoading, data: localSkills, error: localError } = useQuery({
     queryKey: skillsQueryKey,
     queryFn: () => settingsApi.listManagedSkills(repoId, directory),
-    enabled: open && (!!repoId || !!directory),
+    enabled: open && !isRemoteServer && (!!repoId || !!directory),
+    staleTime: 30000,
+  })
+
+  const { isLoading: isRemoteLoading, data: remoteSkillInfos, error: remoteError } = useQuery({
+    queryKey: serverScopedKey(['opencode', 'skills', directory], serverId),
+    queryFn: () => listSkills(directory, serverId),
+    enabled: open && isRemoteServer && Boolean(directory),
     staleTime: 30000,
   })
 
+  const remoteSkills = useMemo(
+    () => remoteSkillInfos?.map(toRemoteSkillFileInfo),
+    [remoteSkillInfos],
+  )
+  const skills = isRemoteServer ? remoteSkills : localSkills
+  const isLoading = isRemoteServer ? isRemoteLoading : isLocalLoading
+  const error = isRemoteServer ? remoteError : localError
+
   const canLoad = !!sessionId
   const loadSkill = useLoadSkill(sessionId)
+  const description = isRemoteServer
+    ? canLoad ? 'Load a skill from this server into the current session' : 'Skills available on this server'
+    : canLoad ? 'Search and load a skill into the current session' : 'Skills available for this repository'
+  const emptyHint = isRemoteServer
+    ? 'This server exposes no skills for this location.'
+    : 'Install a skill or add one to .opencode/skills/<name>/SKILL.md.'
 
   const handleLoad = (skill: SkillFileInfo) => {
     loadSkill.mutate({ skillName: skill.name })
@@ -65,43 +102,49 @@ export function RepoSkillsContent({
     <div className="flex min-h-0 flex-1 flex-col">
       <div className="flex shrink-0 items-center justify-between gap-2 px-4 py-3 sm:px-6">
         <p className="text-sm text-muted-foreground">
-          {canLoad ? 'Search and load a skill into the current session' : 'Skills available for this repository'}
+          {description}
         </p>
-        <Button type="button" variant="outline" size="sm" onClick={() => setInstallDialogOpen(true)}>
-          <Download className="h-4 w-4 mr-1" />
-          Install Skill
-        </Button>
+        {!isRemoteServer && (
+          <Button type="button" variant="outline" size="sm" onClick={() => setInstallDialogOpen(true)}>
+            <Download className="h-4 w-4 mr-1" />
+            Install Skill
+          </Button>
+        )}
       </div>
 
       <div className="min-h-0 flex-1 overflow-y-auto p-4 sm:p-6">
         <SkillLibraryList
           isLoading={isLoading}
-          data={data}
+          data={skills}
           error={error as Error | null}
           primaryAction={canLoad ? { label: 'Load', onClick: handleLoad } : undefined}
-          rowActions={[{ label: 'Delete', onClick: setDeleteSkill, destructive: true }]}
+          rowActions={isRemoteServer ? [] : [{ label: 'Delete', onClick: setDeleteSkill, destructive: true }]}
           emptyTitle="No skills found"
-          emptyHint="Install a skill or add one to .opencode/skills/<name>/SKILL.md."
+          emptyHint={emptyHint}
           maxHeightClassName="max-h-none"
         />
       </div>
 
-      <SkillInstallDialog
-        open={installDialogOpen}
-        onOpenChange={setInstallDialogOpen}
-        onInstalled={handleInstalled}
-      />
-
-      <DeleteDialog
-        open={deleteSkill !== null}
-        onOpenChange={(isOpen) => !isOpen && setDeleteSkill(null)}
-        onConfirm={confirmDelete}
-        onCancel={() => setDeleteSkill(null)}
-        title="Delete Skill"
-        description="Delete this managed skill directory and bundled files? This action cannot be undone."
-        itemName={deleteSkill?.name}
-        isDeleting={isDeleting}
-      />
+      {!isRemoteServer && (
+        <SkillInstallDialog
+          open={installDialogOpen}
+          onOpenChange={setInstallDialogOpen}
+          onInstalled={handleInstalled}
+        />
+      )}
+
+      {!isRemoteServer && (
+        <DeleteDialog
+          open={deleteSkill !== null}
+          onOpenChange={(isOpen) => !isOpen && setDeleteSkill(null)}
+          onConfirm={confirmDelete}
+          onCancel={() => setDeleteSkill(null)}
+          title="Delete Skill"
+          description="Delete this managed skill directory and bundled files? This action cannot be undone."
+          itemName={deleteSkill?.name}
+          isDeleting={isDeleting}
+        />
+      )}
     </div>
   )
 }
diff --git a/frontend/src/components/session/BackgroundWorkBar.test.tsx b/frontend/src/components/session/BackgroundWorkBar.test.tsx
index 5dcef7ac1..6645bfe98 100644
--- a/frontend/src/components/session/BackgroundWorkBar.test.tsx
+++ b/frontend/src/components/session/BackgroundWorkBar.test.tsx
@@ -150,7 +150,7 @@ describe('BackgroundWorkBar', () => {
 
   it('renders nothing when there is no running or background work', async () => {
     const { container } = renderBar([], false)
-    await waitFor(() => expect(api.listShells).toHaveBeenCalledWith('/repo'))
+    await waitFor(() => expect(api.listShells).toHaveBeenCalledWith('/repo', 'local'))
     expect(container).toBeEmptyDOMElement()
   })
 
@@ -159,7 +159,7 @@ describe('BackgroundWorkBar', () => {
 
     fireEvent.click(await screen.findByRole('button', { name: /Move to background/ }))
 
-    await waitFor(() => expect(api.backgroundSession).toHaveBeenCalledWith('session-1'))
+    await waitFor(() => expect(api.backgroundSession).toHaveBeenCalledWith('session-1', 'local'))
   })
 
   it('hides the background action once the session is idle', async () => {
@@ -180,7 +180,7 @@ describe('BackgroundWorkBar', () => {
 
     fireEvent.click(screen.getByRole('button', { name: 'Kill npm run dev' }))
 
-    await waitFor(() => expect(api.removeShell).toHaveBeenCalledWith('dev', '/repo'))
+    await waitFor(() => expect(api.removeShell).toHaveBeenCalledWith('dev', '/repo', 'local'))
     await waitFor(() => expect(container).toBeEmptyDOMElement())
     clearShellExitRecord('/repo', 'dev')
   })
@@ -443,7 +443,7 @@ describe('BackgroundWorkBar', () => {
     fireEvent.click(screen.getByRole('button', { name: 'Output' }))
 
     expect(await screen.findByText('server listening on 3000')).toBeInTheDocument()
-    expect(api.readShellOutput).toHaveBeenCalledWith('dev', '/repo', 0, 50_000)
+    expect(api.readShellOutput).toHaveBeenCalledWith('dev', '/repo', 0, 50_000, 'local')
   })
 
   it('reads the final output when the shell exits during an in-flight poll', async () => {
diff --git a/frontend/src/components/session/BackgroundWorkBar.tsx b/frontend/src/components/session/BackgroundWorkBar.tsx
index c7429a620..3cb7f4701 100644
--- a/frontend/src/components/session/BackgroundWorkBar.tsx
+++ b/frontend/src/components/session/BackgroundWorkBar.tsx
@@ -3,6 +3,7 @@ import { Bot, Check, ChevronDown, ChevronUp, ExternalLink, Loader2, MoveDownRigh
 import { useShallow } from 'zustand/react/shallow'
 import type { SessionMessageInfo } from '@opencode-manager/shared/opencode'
 import { readShellOutput } from '@/api/opencode'
+import { useOpenCodeServerId } from '@/contexts/OpenCodeServerContext'
 import { Button } from '@/components/ui/button'
 import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle } from '@/components/ui/dialog'
 import { useBackgroundSession, useChildSessionReconciliation } from '@/hooks/useOpenCode'
@@ -49,6 +50,7 @@ function appendShellOutput(previous: ShellOutputState, output: string, truncated
 }
 
 function useShellOutput(shellID: string, directory: string, running: boolean): ShellOutputState {
+  const serverId = useOpenCodeServerId()
   const [state, setState] = useState<ShellOutputState>({ output: '', truncated: false })
   const cursorRef = useRef(0)
 
@@ -64,7 +66,7 @@ function useShellOutput(shellID: string, directory: string, running: boolean): S
       let truncated = false
       try {
         for (;;) {
-          const chunk = await readShellOutput(shellID, directory, cursor, SHELL_OUTPUT_LIMIT)
+          const chunk = await readShellOutput(shellID, directory, cursor, SHELL_OUTPUT_LIMIT, serverId)
           output += chunk.output
           if (chunk.truncated) truncated = true
           if (chunk.cursor <= cursor) break
@@ -99,7 +101,7 @@ function useShellOutput(shellID: string, directory: string, running: boolean): S
       cancelled = true
       clearInterval(interval)
     }
-  }, [shellID, directory, running])
+  }, [shellID, directory, running, serverId])
 
   return state
 }
diff --git a/frontend/src/components/session/SessionPickerDialog.test.tsx b/frontend/src/components/session/SessionPickerDialog.test.tsx
index bc3eb83f9..0e08e4037 100644
--- a/frontend/src/components/session/SessionPickerDialog.test.tsx
+++ b/frontend/src/components/session/SessionPickerDialog.test.tsx
@@ -1,13 +1,15 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { useState } from 'react'
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
-import { render, screen, fireEvent, waitFor, act } from '@testing-library/react'
+import { render, screen, fireEvent, waitFor, act, within } from '@testing-library/react'
 import userEvent from '@testing-library/user-event'
+import { LOCAL_OPENCODE_SERVER_ID } from '@opencode-manager/shared/schemas'
 import type { Repo, Session } from '@/api/types'
 import type { ActiveWorkGroups, ActiveWorkItem, ActiveWorkState } from '@/lib/activeWork'
 import { stubMatchMedia } from '@/test/test-utils'
 import { DEFAULT_ACTIVITY_WINDOW_MINUTES } from '@/api/types/settings'
 import { KeyboardShortcutsProvider } from '@/contexts/KeyboardShortcutsContext'
+import { OpenCodeServerProvider } from '@/contexts/OpenCodeServerContext'
 import { SessionPickerDialog } from './SessionPickerDialog'
 
 const mocks = vi.hoisted(() => ({
@@ -21,6 +23,7 @@ const mocks = vi.hoisted(() => ({
   sessionsHook: vi.fn(),
   fetchNextPage: vi.fn(),
   deleteSessionMock: vi.fn(),
+  deletedSessionServerId: null as string | null,
   togglePinMock: vi.fn(),
   getOpenCodeLocation: vi.fn(),
   sessionPins: [] as Array<{ sessionId: string; directory: string; pinnedAt: number }>,
@@ -48,6 +51,7 @@ vi.mock('@/api/opencode', async (importOriginal) => {
 
 vi.mock('@/hooks/useOpenCode', async (importOriginal) => {
   const actual = await importOriginal<typeof import('@/hooks/useOpenCode')>()
+  const { useOpenCodeServerId } = await import('@/contexts/OpenCodeServerContext')
   return {
     ...actual,
     useSessionsAcrossDirectories: (
@@ -73,7 +77,16 @@ vi.mock('@/hooks/useOpenCode', async (importOriginal) => {
         isFetchNextPageError: false,
       }
     },
-    useDeleteSession: () => ({ mutateAsync: mocks.deleteSessionMock, isPending: false }),
+    useDeleteSession: () => {
+      const serverId = useOpenCodeServerId()
+      return {
+        mutateAsync: (target: unknown) => {
+          mocks.deletedSessionServerId = serverId
+          return mocks.deleteSessionMock(target)
+        },
+        isPending: false,
+      }
+    },
   }
 })
 
@@ -136,13 +149,15 @@ function activeWorkItem(
     key: `${directory}:${id}`,
     session: itemSession,
     repo: itemRepo,
+    serverId: null,
+    serverName: null,
     state,
     updatedAt: itemSession.time.updated,
     path: `/repos/${itemRepo.id}/sessions/${id}`,
   }
 }
 
-function renderWithClient(ui: React.ReactElement) {
+function renderWithClient(ui: React.ReactElement, serverId?: string) {
   const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
   const directory = mocks.repos[0]?.fullPath
   if (mocks.locationData && directory) {
@@ -150,7 +165,13 @@ function renderWithClient(ui: React.ReactElement) {
   }
   return render(
     <QueryClientProvider client={queryClient}>
-      <KeyboardShortcutsProvider>{ui}</KeyboardShortcutsProvider>
+      <KeyboardShortcutsProvider>
+        {serverId ? (
+          <OpenCodeServerProvider serverId={serverId}>{ui}</OpenCodeServerProvider>
+        ) : (
+          ui
+        )}
+      </KeyboardShortcutsProvider>
     </QueryClientProvider>,
   )
 }
@@ -190,6 +211,7 @@ describe('SessionPickerDialog', () => {
     stubMatchMedia(true)
     localStorage.clear()
     mocks.deleteSessionMock.mockResolvedValue(undefined)
+    mocks.deletedSessionServerId = null
     mocks.locationData = {
       directory: '/w/a',
       project: { id: 'global', directory: '/w/a', canonical: '/w/a' },
@@ -877,4 +899,112 @@ describe('SessionPickerDialog', () => {
       pinned: true,
     })
   })
+
+  describe('linked-server mode', () => {
+    beforeEach(() => {
+      mocks.repos = [repo(1, 'alpha', '/w/a')]
+      mocks.sessionsData = [session('ses_remote', 'Remote session', '/home/me/app')]
+    })
+
+    it('lists the project sessions without Manager-only tabs and reports the chosen server session', async () => {
+      const onSelectRemoteSession = vi.fn()
+      renderPicker({
+        remote: {
+          serverId: 'srv_kitchen',
+          serverName: 'Kitchen',
+          projectDirectory: '/home/me/app',
+        },
+        onSelectRemoteSession,
+      })
+
+      expect(screen.queryByRole('tab', { name: 'Projects' })).not.toBeInTheDocument()
+      expect(screen.getByRole('tab', { name: 'Active' })).toBeInTheDocument()
+
+      const row = await screen.findByRole('option', { name: /Remote session/ })
+      expect(row).toHaveTextContent('Kitchen')
+
+      fireEvent.click(row)
+
+      expect(onSelectRemoteSession).toHaveBeenCalledWith(
+        expect.objectContaining({ id: 'ses_remote' }),
+        'srv_kitchen',
+      )
+    })
+
+    it('navigates a remote active work row through the owning server', async () => {
+      const onSelectRemoteSession = vi.fn()
+      mocks.activeWorkGroups = {
+        needsInput: [
+          {
+            key: '/home/me/app/ses_remote',
+            session: session('ses_remote', 'Remote pending', '/home/me/app'),
+            repo: null,
+            serverId: 'srv_kitchen',
+            serverName: 'Kitchen',
+            state: 'needs-input',
+            updatedAt: Date.now(),
+            path: '/servers/srv_kitchen/sessions/ses_remote',
+          },
+        ],
+        running: [],
+        recent: [],
+      }
+      renderPicker({
+        remote: {
+          serverId: 'srv_kitchen',
+          serverName: 'Kitchen',
+          projectDirectory: '/home/me/app',
+        },
+        onSelectRemoteSession,
+      })
+      openActiveTab()
+
+      const row = await screen.findByRole('option', { name: /Remote pending/ })
+      expect(row).toHaveTextContent('Kitchen')
+      expect(screen.queryByRole('button', { name: 'Session actions' })).not.toBeInTheDocument()
+
+      fireEvent.click(row)
+
+      expect(onSelectRemoteSession).toHaveBeenCalledWith(
+        expect.objectContaining({ id: 'ses_remote' }),
+        'srv_kitchen',
+      )
+    })
+
+    it('deletes a local active work row through the local server', async () => {
+      const user = userEvent.setup()
+      mocks.activeWorkGroups = {
+        needsInput: [],
+        running: [activeWorkItem('ses_local', 'Local task', '/w/a', 'running')],
+        recent: [],
+      }
+      renderWithClient(
+        <SessionPickerDialog
+          open
+          onOpenChange={vi.fn()}
+          currentRepo={mocks.repos[0]}
+          onSelectSession={vi.fn()}
+          onDeleteActiveSession={vi.fn()}
+          onSelectRepo={vi.fn()}
+          onSelectRemoteSession={vi.fn()}
+          remote={{ serverId: 'srv_kitchen', serverName: 'Kitchen', projectDirectory: '/home/me/app' }}
+        />,
+        'srv_kitchen',
+      )
+      openActiveTab()
+
+      await screen.findByRole('option', { name: /Local task/ })
+
+      await user.click(screen.getByRole('button', { name: 'Session actions' }))
+      await user.click(await screen.findByText('Delete'))
+
+      const dialog = await screen.findByRole('dialog', { name: 'Delete Session' })
+      await user.click(within(dialog).getByRole('button', { name: 'Delete' }))
+
+      await waitFor(() =>
+        expect(mocks.deleteSessionMock).toHaveBeenCalledWith({ id: 'ses_local', directory: '/w/a' }),
+      )
+      expect(mocks.deletedSessionServerId).toBe(LOCAL_OPENCODE_SERVER_ID)
+    })
+  })
 })
diff --git a/frontend/src/components/session/SessionPickerDialog.tsx b/frontend/src/components/session/SessionPickerDialog.tsx
index 677c73501..fb4fb849c 100644
--- a/frontend/src/components/session/SessionPickerDialog.tsx
+++ b/frontend/src/components/session/SessionPickerDialog.tsx
@@ -2,7 +2,10 @@ import { memo, useCallback, useEffect, useId, useMemo, useRef, useState } from '
 import { useQuery } from '@tanstack/react-query'
 import { format, startOfDay } from 'date-fns'
 import { MoreHorizontal, Pin, PinOff } from 'lucide-react'
+import { LOCAL_OPENCODE_SERVER_ID } from '@opencode-manager/shared/schemas'
 import { getOpenCodeLocation } from '@/api/opencode'
+import { OpenCodeServerProvider, useOpenCodeServerId } from '@/contexts/OpenCodeServerContext'
+import { serverScopedKey } from '@/lib/serverScope'
 import type { Repo, Session } from '@/api/types'
 import { ACTIVE_WORK_GROUPS, MS_PER_MINUTE, formatActivityEmptyMessage } from '@/lib/activeWork'
 import { Button } from '@/components/ui/button'
@@ -46,6 +49,7 @@ const NEAR_BOTTOM_PX = 240
 type SessionPickerTab = 'active' | 'sessions' | 'projects'
 
 const SESSION_PICKER_TABS: SessionPickerTab[] = ['active', 'sessions', 'projects']
+const REMOTE_SESSION_PICKER_TABS: SessionPickerTab[] = ['active', 'sessions']
 
 const SESSION_PICKER_TAB_LABELS: Record<SessionPickerTab, string> = {
   active: 'Active',
@@ -53,9 +57,15 @@ const SESSION_PICKER_TAB_LABELS: Record<SessionPickerTab, string> = {
   projects: 'Projects',
 }
 
-function nextSessionPickerTab(tab: SessionPickerTab): SessionPickerTab {
-  const index = SESSION_PICKER_TABS.indexOf(tab)
-  return SESSION_PICKER_TABS[(index + 1) % SESSION_PICKER_TABS.length]
+function nextSessionPickerTab(tab: SessionPickerTab, tabs: SessionPickerTab[]): SessionPickerTab {
+  const index = tabs.indexOf(tab)
+  return tabs[(index + 1) % tabs.length]
+}
+
+interface RemotePickerScope {
+  serverId: string
+  serverName?: string
+  projectDirectory?: string
 }
 
 interface SessionPickerDialogProps {
@@ -64,14 +74,19 @@ interface SessionPickerDialogProps {
   currentRepo: Repo | undefined
   activeSessionID?: string
   onSelectSession: (session: Session, repo: Repo) => void
+  onSelectRemoteSession?: (session: Session, serverId: string) => void
   onDeleteActiveSession: () => void
   onSelectRepo: (repo: Repo) => void
+  /** Set on a linked-server route to list that server's sessions instead of Manager repos. */
+  remote?: RemotePickerScope
 }
 
 interface SessionPickerRow {
   key: string
   session: Session
-  repo: Repo
+  repo?: Repo
+  serverId?: string
+  serverName?: string
   updatedAt?: number
 }
 
@@ -85,14 +100,11 @@ function buildSections(
   sessions: Session[],
   pinnedKeys: ReadonlySet<string>,
   keyFn: (session: Session) => string,
-  resolveRepo: (session: Session) => Repo | undefined,
+  resolveRepo?: (session: Session) => Repo | undefined,
 ): SessionPickerSection[] {
   const { pinned, today, older } = partitionSessions(sessions, pinnedKeys, keyFn)
   const toRows = (group: Session[]): SessionPickerRow[] =>
-    group.flatMap((session) => {
-      const repo = resolveRepo(session)
-      return repo ? [{ key: keyFn(session), session, repo }] : []
-    })
+    group.map((session) => ({ key: keyFn(session), session, repo: resolveRepo?.(session) }))
 
   const sections: SessionPickerSection[] = []
   const pinnedRows = toRows(pinned)
@@ -187,6 +199,7 @@ interface SessionPickerRowItemProps {
   isPinned: boolean
   isPendingDelete: boolean
   showRepo: boolean
+  showActions: boolean
   label?: string
   onOpen: (row: SessionPickerRow) => void
   onHover: (index: number) => void
@@ -204,6 +217,7 @@ const SessionPickerRowItem = memo(function SessionPickerRowItem({
   isPinned,
   isPendingDelete,
   showRepo,
+  showActions,
   label,
   onOpen,
   onHover,
@@ -261,13 +275,18 @@ const SessionPickerRowItem = memo(function SessionPickerRowItem({
                 : 'text-muted-foreground',
           )}
         >
-          {showRepo && <span className="max-w-32 truncate">{getRepoDisplayName(row.repo)}</span>}
+          {showRepo && row.repo ? (
+            <span className="max-w-32 truncate">{getRepoDisplayName(row.repo)}</span>
+          ) : null}
+          {showRepo && !row.repo && (row.serverName || row.serverId) ? (
+            <span className="max-w-32 truncate">{row.serverName ?? row.serverId}</span>
+          ) : null}
           {!showRepo && label && <span className="max-w-32 truncate">{label}</span>}
           <span>{formatShortRelativeTime(new Date(row.updatedAt ?? row.session.time.updated))}</span>
         </span>
       </div>
       <div className="flex shrink-0 items-center pr-1">
-        <DropdownMenu>
+        {row.serverId || !showActions ? null : <DropdownMenu>
           <DropdownMenuTrigger asChild>
             <Button
               type="button"
@@ -289,7 +308,7 @@ const SessionPickerRowItem = memo(function SessionPickerRowItem({
             </DropdownMenuItem>
             <DropdownMenuItem onClick={() => onRequestDelete(row.session)}>Delete</DropdownMenuItem>
           </DropdownMenuContent>
-        </DropdownMenu>
+        </DropdownMenu>}
       </div>
     </div>
   )
@@ -299,6 +318,7 @@ interface SessionPickerRowActionsOptions {
   directories: string[]
   activeSessionID?: string
   onSelectSession: (session: Session, repo: Repo) => void
+  onSelectRemoteSession?: (session: Session, serverId: string) => void
   onDeleteActiveSession: () => void
 }
 
@@ -323,6 +343,7 @@ function useSessionPickerRowActions({
   directories,
   activeSessionID,
   onSelectSession,
+  onSelectRemoteSession,
   onDeleteActiveSession,
 }: SessionPickerRowActionsOptions): SessionPickerRowActions {
   const { data: sessionPins } = useSessionPins()
@@ -339,9 +360,13 @@ function useSessionPickerRowActions({
   const openRow = useCallback(
     (row: SessionPickerRow | undefined) => {
       if (!row) return
-      onSelectSession(row.session, row.repo)
+      if (row.serverId) {
+        onSelectRemoteSession?.(row.session, row.serverId)
+        return
+      }
+      if (row.repo) onSelectSession(row.session, row.repo)
     },
-    [onSelectSession],
+    [onSelectSession, onSelectRemoteSession],
   )
 
   const performDelete = useCallback(
@@ -356,7 +381,7 @@ function useSessionPickerRowActions({
 
   const deleteRow = useCallback(
     (row: SessionPickerRow | undefined) => {
-      if (!row) return
+      if (!row || row.serverId) return
       if (pendingDeleteKey !== row.key) {
         setPendingDeleteKey(row.key)
         return
@@ -370,6 +395,7 @@ function useSessionPickerRowActions({
 
   const handleTogglePin = useCallback(
     (row: SessionPickerRow) => {
+      if (row.serverId) return
       togglePin.mutate({
         sessionId: row.session.id,
         directory: row.session.location.directory,
@@ -429,6 +455,7 @@ interface SessionPickerListProps {
   pinnedKeys: ReadonlySet<string>
   pendingDeleteKey: string | null
   showRepo: boolean
+  showRowActions?: boolean
   labelFor?: (row: SessionPickerRow) => string | undefined
   emptyState: React.ReactNode
   onOpenRow: (row: SessionPickerRow) => void
@@ -453,6 +480,7 @@ function SessionPickerList({
   pinnedKeys,
   pendingDeleteKey,
   showRepo,
+  showRowActions = true,
   labelFor,
   emptyState,
   onOpenRow,
@@ -502,6 +530,7 @@ function SessionPickerList({
                     isPinned={pinnedKeys.has(row.key)}
                     isPendingDelete={pendingDeleteKey === row.key}
                     showRepo={showRepo}
+                    showActions={showRowActions}
                     label={labelFor?.(row)}
                     onOpen={onOpenRow}
                     onHover={onHoverRow}
@@ -525,6 +554,7 @@ interface SessionPickerContentProps {
   currentRepo: Repo | undefined
   activeSessionID?: string
   onSelectSession: (session: Session, repo: Repo) => void
+  onSelectRemoteSession?: (session: Session, serverId: string) => void
   onDeleteActiveSession: () => void
   switchHint: string
   searchInputRef: React.RefObject<HTMLInputElement | null>
@@ -536,6 +566,7 @@ function SessionPickerContent({
   currentRepo,
   activeSessionID,
   onSelectSession,
+  onSelectRemoteSession,
   onDeleteActiveSession,
   switchHint,
   searchInputRef,
@@ -553,9 +584,10 @@ function SessionPickerContent({
     return map
   }, [repos, currentRepo])
 
+  const serverId = useOpenCodeServerId()
   const locationQuery = useQuery({
-    queryKey: ['opencode', 'location', currentRepo?.fullPath],
-    queryFn: () => getOpenCodeLocation(currentRepo!.fullPath),
+    queryKey: serverScopedKey(['opencode', 'location', currentRepo?.fullPath], serverId),
+    queryFn: () => getOpenCodeLocation(currentRepo!.fullPath, serverId),
     enabled: !allProjects && Boolean(currentRepo?.fullPath),
     staleTime: 5 * 60 * 1000,
   })
@@ -613,11 +645,18 @@ function SessionPickerContent({
     directories,
     activeSessionID,
     onSelectSession,
+    onSelectRemoteSession,
     onDeleteActiveSession,
   })
 
   const sections = useMemo(
-    () => buildSections(filteredSessions, pinnedKeys, getSessionKey, resolveRepo),
+    () =>
+      buildSections(
+        filteredSessions.filter((session) => Boolean(resolveRepo(session))),
+        pinnedKeys,
+        getSessionKey,
+        resolveRepo,
+      ),
     [filteredSessions, pinnedKeys, resolveRepo],
   )
   const rows = useMemo(() => sections.flatMap((section) => section.rows), [sections])
@@ -784,6 +823,7 @@ interface ActivePickerContentProps {
   open: boolean
   activeSessionID?: string
   onSelectSession: (session: Session, repo: Repo) => void
+  onSelectRemoteSession?: (session: Session, serverId: string) => void
   onDeleteActiveSession: () => void
   switchHint: string
   searchInputRef: React.RefObject<HTMLInputElement | null>
@@ -793,6 +833,7 @@ function ActivePickerContent({
   open,
   activeSessionID,
   onSelectSession,
+  onSelectRemoteSession,
   onDeleteActiveSession,
   switchHint,
   searchInputRef,
@@ -812,7 +853,14 @@ function ActivePickerContent({
       const rows: SessionPickerRow[] = []
       for (const item of groups[definition.key]) {
         if (needle && !(item.session.title ?? '').toLowerCase().includes(needle)) continue
-        rows.push({ key: item.key, session: item.session, repo: item.repo, updatedAt: item.updatedAt })
+        rows.push({
+          key: item.key,
+          session: item.session,
+          repo: item.repo ?? undefined,
+          serverId: item.serverId ?? undefined,
+          serverName: item.serverName ?? undefined,
+          updatedAt: item.updatedAt,
+        })
       }
       return rows.length > 0 ? [{ id: definition.key, heading: definition.heading, rows }] : []
     })
@@ -835,7 +883,10 @@ function ActivePickerContent({
   } = usePickerCursor(rows, defaultCursorKey)
 
   const directories = useMemo(
-    () => Array.from(new Set(rows.map((row) => row.session.location.directory))),
+    () =>
+      Array.from(
+        new Set(rows.filter((row) => !row.serverId).map((row) => row.session.location.directory)),
+      ),
     [rows],
   )
 
@@ -852,6 +903,7 @@ function ActivePickerContent({
     directories,
     activeSessionID,
     onSelectSession,
+    onSelectRemoteSession,
     onDeleteActiveSession,
   })
 
@@ -931,14 +983,179 @@ function ActivePickerContent({
   )
 }
 
+const EMPTY_PINNED_KEYS: ReadonlySet<string> = new Set()
+
+interface RemoteSessionPickerContentProps {
+  open: boolean
+  serverName?: string
+  projectDirectory?: string
+  activeSessionID?: string
+  onSelectSession: (session: Session) => void
+  switchHint: string
+  searchInputRef: React.RefObject<HTMLInputElement | null>
+}
+
+function RemoteSessionPickerContent({
+  open,
+  serverName,
+  projectDirectory,
+  activeSessionID,
+  onSelectSession,
+  switchHint,
+  searchInputRef,
+}: RemoteSessionPickerContentProps) {
+  const listRef = useRef<HTMLDivElement>(null)
+  const listId = useId()
+  const optionBaseId = useId()
+
+  const {
+    query,
+    setQuery,
+    trimmedQuery,
+    filteredSessions,
+    isSearchPending,
+    isLoading,
+    fetchNextPage,
+    isFetchingNextPage,
+    isFetchNextPageError,
+    canFetchNextPage,
+  } = useSessionSearch(projectDirectory ? [projectDirectory] : [])
+
+  const sections = useMemo(
+    () => buildSections(filteredSessions, EMPTY_PINNED_KEYS, getSessionKey),
+    [filteredSessions],
+  )
+  const rows = useMemo(() => sections.flatMap((section) => section.rows), [sections])
+
+  const activeRow = useMemo(
+    () => rows.find((row) => row.session.id === activeSessionID),
+    [rows, activeSessionID],
+  )
+  const defaultCursorKey = !trimmedQuery && activeRow ? activeRow.key : rows[0]?.key ?? null
+
+  const {
+    rowIndexByKey,
+    cursorIndex,
+    cursorRow,
+    registerRef,
+    moveCursor,
+    resetCursor,
+  } = usePickerCursor(rows, defaultCursorKey)
+
+  const openRow = useCallback(
+    (row: SessionPickerRow | undefined) => {
+      if (row) onSelectSession(row.session)
+    },
+    [onSelectSession],
+  )
+
+  useEffect(() => {
+    resetCursor()
+  }, [trimmedQuery, resetCursor])
+
+  const handleSearchKeyDown = usePickerKeyNav({
+    rows,
+    cursorIndex,
+    cursorRow,
+    moveCursor,
+    onOpenRow: openRow,
+  })
+
+  const handleListScroll = useCallback(
+    (event: React.UIEvent<HTMLDivElement>) => {
+      const { scrollTop, scrollHeight, clientHeight } = event.currentTarget
+      if (scrollHeight - scrollTop - clientHeight <= NEAR_BOTTOM_PX && canFetchNextPage) {
+        void fetchNextPage()
+      }
+    },
+    [canFetchNextPage, fetchNextPage],
+  )
+
+  const labelFor = useCallback(() => serverName, [serverName])
+
+  return (
+    <div className="mt-4 flex min-h-0 flex-1 flex-col">
+      <PickerSearchBar
+        inputRef={searchInputRef}
+        listId={listId}
+        open={open}
+        activeDescendantId={cursorIndex >= 0 ? optionId(optionBaseId, cursorIndex) : undefined}
+        value={query}
+        onChange={setQuery}
+        onKeyDown={handleSearchKeyDown}
+        placeholder="Search sessions..."
+        name="remote-session-picker-search"
+      />
+
+      <SessionPickerList
+        listRef={listRef}
+        listId={listId}
+        optionBaseId={optionBaseId}
+        ariaLabel="Sessions"
+        sections={sections}
+        rows={rows}
+        rowIndexByKey={rowIndexByKey}
+        cursorIndex={cursorIndex}
+        activeSessionID={activeSessionID}
+        pinnedKeys={EMPTY_PINNED_KEYS}
+        pendingDeleteKey={null}
+        showRepo={false}
+        showRowActions={false}
+        labelFor={labelFor}
+        emptyState={
+          isLoading
+            ? 'Loading sessions...'
+            : isSearchPending
+              ? 'Searching sessions...'
+              : trimmedQuery
+                ? 'No sessions found'
+                : 'No sessions yet'
+        }
+        onOpenRow={openRow}
+        onHoverRow={moveCursor}
+        onTogglePin={() => undefined}
+        onRequestDelete={() => undefined}
+        registerRef={registerRef}
+        onScroll={handleListScroll}
+      >
+        {isFetchNextPageError && (
+          <div className="flex flex-col items-center gap-2 py-4">
+            <p className="text-sm text-muted-foreground">Failed to load more sessions</p>
+            <Button
+              variant="outline"
+              size="sm"
+              onClick={() => {
+                void fetchNextPage()
+              }}
+              disabled={isFetchingNextPage}
+            >
+              Retry
+            </Button>
+          </div>
+        )}
+        {isFetchingNextPage && rows.length > 0 && (
+          <div className="py-4 text-center text-sm text-muted-foreground">Loading more sessions...</div>
+        )}
+      </SessionPickerList>
+
+      <div className="mt-2 shrink-0 px-4 text-xs text-muted-foreground pointer-coarse:hidden sm:px-0">
+        ↑↓ move · Enter open
+        {switchHint ? ` · ${switchHint} sessions` : ''}
+      </div>
+    </div>
+  )
+}
+
 export function SessionPickerDialog({
   open,
   onOpenChange,
   currentRepo,
   activeSessionID,
   onSelectSession,
+  onSelectRemoteSession,
   onDeleteActiveSession,
   onSelectRepo,
+  remote,
 }: SessionPickerDialogProps) {
   const searchInputRef = useRef<HTMLInputElement>(null)
   const activeSearchInputRef = useRef<HTMLInputElement>(null)
@@ -957,6 +1174,8 @@ export function SessionPickerDialog({
     },
     [preferences],
   )
+  const isRemote = remote !== undefined
+  const pickerTabs = isRemote ? REMOTE_SESSION_PICKER_TABS : SESSION_PICKER_TABS
   const [tab, setTab] = useState<SessionPickerTab>('sessions')
   const [prevOpen, setPrevOpen] = useState(open)
 
@@ -965,10 +1184,12 @@ export function SessionPickerDialog({
     if (open) setTab('sessions')
   }
 
+  const activeTab: SessionPickerTab = isRemote && tab === 'projects' ? 'sessions' : tab
+
   const toggleTab = useCallback(() => {
     focusSearchAfterSwitchRef.current = true
-    setTab((current) => nextSessionPickerTab(current))
-  }, [])
+    setTab((current) => nextSessionPickerTab(current, pickerTabs))
+  }, [pickerTabs])
 
   useShortcutActions({ switchPickerTab: open ? toggleTab : undefined })
 
@@ -980,12 +1201,12 @@ export function SessionPickerDialog({
     if (!hasFinePointer && !focusSearchAfterSwitchRef.current) return
     const frame = requestAnimationFrame(() => {
       focusSearchAfterSwitchRef.current = false
-      if (tab === 'projects') projectSearchInputRef.current?.focus()
-      else if (tab === 'active') activeSearchInputRef.current?.focus()
+      if (activeTab === 'projects') projectSearchInputRef.current?.focus()
+      else if (activeTab === 'active') activeSearchInputRef.current?.focus()
       else searchInputRef.current?.focus()
     })
     return () => cancelAnimationFrame(frame)
-  }, [open, tab, hasFinePointer])
+  }, [open, activeTab, hasFinePointer])
 
   return (
     <Dialog open={open} onOpenChange={onOpenChange}>
@@ -1003,58 +1224,76 @@ export function SessionPickerDialog({
         }}
       >
         <Tabs
-          value={tab}
+          value={activeTab}
           onValueChange={(value) => setTab(value as SessionPickerTab)}
           className="flex min-h-0 w-full min-w-0 flex-1 flex-col gap-0"
         >
           <div className="shrink-0 px-4 pt-4 sm:px-0 sm:pt-6">
-            <DialogTitle className="sr-only">{SESSION_PICKER_TAB_LABELS[tab]}</DialogTitle>
+            <DialogTitle className="sr-only">{SESSION_PICKER_TAB_LABELS[activeTab]}</DialogTitle>
             <TabsList>
               <TabsTrigger value="active">Active</TabsTrigger>
               <TabsTrigger value="sessions">Sessions</TabsTrigger>
-              <TabsTrigger value="projects">Projects</TabsTrigger>
+              {isRemote ? null : <TabsTrigger value="projects">Projects</TabsTrigger>}
             </TabsList>
           </div>
           <TabsContent
             value="active"
             className="mt-0 flex min-h-0 w-full min-w-0 flex-1 flex-col px-0"
           >
-            <ActivePickerContent
-              open={open}
-              activeSessionID={activeSessionID}
-              onSelectSession={onSelectSession}
-              onDeleteActiveSession={onDeleteActiveSession}
-              switchHint={switchHint}
-              searchInputRef={activeSearchInputRef}
-            />
+            <OpenCodeServerProvider serverId={LOCAL_OPENCODE_SERVER_ID}>
+              <ActivePickerContent
+                open={open}
+                activeSessionID={activeSessionID}
+                onSelectSession={onSelectSession}
+                onSelectRemoteSession={onSelectRemoteSession}
+                onDeleteActiveSession={onDeleteActiveSession}
+                switchHint={switchHint}
+                searchInputRef={activeSearchInputRef}
+              />
+            </OpenCodeServerProvider>
           </TabsContent>
           <TabsContent
             value="sessions"
             className="mt-0 flex min-h-0 w-full min-w-0 flex-1 flex-col px-0"
           >
-            <SessionPickerContent
-              open={open}
-              currentRepo={currentRepo}
-              activeSessionID={activeSessionID}
-              onSelectSession={onSelectSession}
-              onDeleteActiveSession={onDeleteActiveSession}
-              switchHint={switchHint}
-              searchInputRef={searchInputRef}
-              hasFinePointer={hasFinePointer}
-            />
-          </TabsContent>
-          <TabsContent
-            value="projects"
-            className="mt-0 flex min-h-0 w-full min-w-0 flex-1 flex-col px-0"
-          >
-            <ProjectPickerContent
-              open={open}
-              currentRepo={currentRepo}
-              onSelectRepo={onSelectRepo}
-              switchHint={switchHint}
-              searchInputRef={projectSearchInputRef}
-            />
+            {remote ? (
+              <RemoteSessionPickerContent
+                open={open}
+                serverName={remote.serverName}
+                projectDirectory={remote.projectDirectory}
+                activeSessionID={activeSessionID}
+                onSelectSession={(session) => onSelectRemoteSession?.(session, remote.serverId)}
+                switchHint={switchHint}
+                searchInputRef={searchInputRef}
+              />
+            ) : (
+              <SessionPickerContent
+                open={open}
+                currentRepo={currentRepo}
+                activeSessionID={activeSessionID}
+                onSelectSession={onSelectSession}
+                onSelectRemoteSession={onSelectRemoteSession}
+                onDeleteActiveSession={onDeleteActiveSession}
+                switchHint={switchHint}
+                searchInputRef={searchInputRef}
+                hasFinePointer={hasFinePointer}
+              />
+            )}
           </TabsContent>
+          {isRemote ? null : (
+            <TabsContent
+              value="projects"
+              className="mt-0 flex min-h-0 w-full min-w-0 flex-1 flex-col px-0"
+            >
+              <ProjectPickerContent
+                open={open}
+                currentRepo={currentRepo}
+                onSelectRepo={onSelectRepo}
+                switchHint={switchHint}
+                searchInputRef={projectSearchInputRef}
+              />
+            </TabsContent>
+          )}
         </Tabs>
       </DialogContent>
     </Dialog>
diff --git a/frontend/src/components/session/SideQuestionDialog.test.tsx b/frontend/src/components/session/SideQuestionDialog.test.tsx
index 5cb98529a..5c8ee81b0 100644
--- a/frontend/src/components/session/SideQuestionDialog.test.tsx
+++ b/frontend/src/components/session/SideQuestionDialog.test.tsx
@@ -78,6 +78,7 @@ describe('SideQuestionDialog', () => {
       'ses_1',
       'what is the answer?',
       expect.any(AbortSignal),
+      'local',
     )
     expect(await screen.findByText('42')).toBeInTheDocument()
   })
@@ -95,7 +96,7 @@ describe('SideQuestionDialog', () => {
     fireEvent.click(screen.getByRole('button', { name: 'Ask' }))
 
     await waitFor(() =>
-      expect(mocks.askSideQuestion).toHaveBeenCalledWith('ses_1', 'why?', expect.any(AbortSignal)),
+      expect(mocks.askSideQuestion).toHaveBeenCalledWith('ses_1', 'why?', expect.any(AbortSignal), 'local'),
     )
     expect(await screen.findByText('because')).toBeInTheDocument()
   })
@@ -111,7 +112,7 @@ describe('SideQuestionDialog', () => {
     fireEvent.click(screen.getByRole('button', { name: 'Retry' }))
 
     await waitFor(() => expect(mocks.askSideQuestion).toHaveBeenCalledTimes(2))
-    expect(mocks.askSideQuestion).toHaveBeenLastCalledWith('ses_1', 'why?', expect.any(AbortSignal))
+    expect(mocks.askSideQuestion).toHaveBeenLastCalledWith('ses_1', 'why?', expect.any(AbortSignal), 'local')
     expect(await screen.findByText('retried answer')).toBeInTheDocument()
   })
 
@@ -132,6 +133,7 @@ describe('SideQuestionDialog', () => {
       'ses_1',
       'question A',
       expect.any(AbortSignal),
+      'local',
     )
   })
 
@@ -152,6 +154,7 @@ describe('SideQuestionDialog', () => {
       'ses_1',
       'question A',
       expect.any(AbortSignal),
+      'local',
     )
   })
 
@@ -189,6 +192,7 @@ describe('SideQuestionDialog', () => {
       'ses_1',
       'question B',
       expect.any(AbortSignal),
+      'local',
     )
     expect(signalB).toBeDefined()
     expect(signalA?.aborted).toBe(true)
diff --git a/frontend/src/components/session/SideQuestionDialog.tsx b/frontend/src/components/session/SideQuestionDialog.tsx
index 1b34884b3..0f42ef42a 100644
--- a/frontend/src/components/session/SideQuestionDialog.tsx
+++ b/frontend/src/components/session/SideQuestionDialog.tsx
@@ -6,6 +6,7 @@ import { Input } from '@/components/ui/input'
 import { CopyButton } from '@/components/ui/copy-button'
 import { TextPart } from '@/components/message/TextPart'
 import { askSideQuestion } from '@/api/opencode'
+import { useOpenCodeServerId } from '@/contexts/OpenCodeServerContext'
 
 interface SideQuestionDialogProps {
   open: boolean
@@ -20,6 +21,7 @@ export function SideQuestionDialog({
   sessionID,
   initialQuestion = '',
 }: SideQuestionDialogProps) {
+  const serverId = useOpenCodeServerId()
   const [question, setQuestion] = useState(initialQuestion)
   const [answer, setAnswer] = useState('')
   const [error, setError] = useState(false)
@@ -43,7 +45,7 @@ export function SideQuestionDialog({
     setAnswer('')
 
     try {
-      const result = await askSideQuestion(sessionID, trimmed, controller.signal)
+      const result = await askSideQuestion(sessionID, trimmed, controller.signal, serverId)
       if (requestRef.current !== requestId || controller.signal.aborted) return
       setAnswer(result)
       setPending(false)
@@ -52,7 +54,7 @@ export function SideQuestionDialog({
       setError(true)
       setPending(false)
     }
-  }, [sessionID])
+  }, [sessionID, serverId])
 
   useEffect(() => {
     if (initialQuestion.trim()) {
diff --git a/frontend/src/components/settings/OpenCodeServerDialog.test.tsx b/frontend/src/components/settings/OpenCodeServerDialog.test.tsx
new file mode 100644
index 000000000..24aae1a81
--- /dev/null
+++ b/frontend/src/components/settings/OpenCodeServerDialog.test.tsx
@@ -0,0 +1,180 @@
+import { beforeAll, describe, expect, it, vi } from 'vitest'
+import { render, screen, waitFor } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+import { buildOpenCodeServerLink, OPENCODE_SERVER_LINK_VERSION, type OpenCodeServer, type OpenCodeServerTestResult } from '@opencode-manager/shared/schemas'
+import { OpenCodeServerDialog, type OpenCodeServerFormValues } from './OpenCodeServerDialog'
+
+const testResult: OpenCodeServerTestResult = {
+  ok: true,
+  version: '2.0.15',
+  versionSupported: true,
+  error: null,
+}
+
+const pairingLink = buildOpenCodeServerLink({
+  kind: 'opencode',
+  name: 'Kitchen',
+  baseUrl: 'https://kitchen.example.com',
+  pairing: { pairUrl: 'https://kitchen.example.com/pair', code: 'pairing-code-0123456789' },
+})
+
+const savedServer: OpenCodeServer = {
+  id: 'srv_1',
+  name: 'Office',
+  baseUrl: 'https://office.example.com',
+  username: 'opencode',
+  enabled: true,
+  hasPassword: true,
+  createdAt: 1,
+  updatedAt: 2,
+}
+
+const originChangeWarning = 'Changing the server address requires re-entering the password or pairing again.'
+
+function renderDialog(options: {
+  server?: OpenCodeServer | null
+  onSubmit?: (values: OpenCodeServerFormValues) => Promise<void>
+} = {}) {
+  const onSubmit = vi.fn(options.onSubmit ?? (async () => {}))
+  const onTest = vi.fn(async () => testResult)
+  const onOpenChange = vi.fn()
+  render(
+    <OpenCodeServerDialog
+      open
+      onOpenChange={onOpenChange}
+      server={options.server}
+      onSubmit={onSubmit}
+      onTest={onTest}
+    />,
+  )
+  return { onSubmit, onTest, onOpenChange }
+}
+
+describe('OpenCodeServerDialog', () => {
+  beforeAll(() => {
+    Element.prototype.hasPointerCapture ??= () => false
+    Element.prototype.setPointerCapture ??= () => {}
+    Element.prototype.releasePointerCapture ??= () => {}
+    Element.prototype.scrollIntoView ??= () => {}
+  })
+
+  it('prefills name and URL from a pasted pairing link and sends pairing on save', async () => {
+    const user = userEvent.setup()
+    const { onSubmit } = renderDialog()
+
+    await user.type(screen.getByLabelText('Pairing link'), pairingLink)
+    await user.click(screen.getByRole('button', { name: 'Use link' }))
+
+    expect(screen.getByText('Pairing with Kitchen')).toBeInTheDocument()
+    expect(screen.getByLabelText('Name')).toHaveValue('Kitchen')
+    expect(screen.getByLabelText('URL')).toHaveValue('https://kitchen.example.com')
+    expect(screen.queryByLabelText('Password')).not.toBeInTheDocument()
+
+    await user.click(screen.getByRole('button', { name: 'Add server' }))
+
+    await waitFor(() => expect(onSubmit).toHaveBeenCalledTimes(1))
+    expect(onSubmit.mock.calls[0][0]).toMatchObject({
+      name: 'Kitchen',
+      baseUrl: 'https://kitchen.example.com',
+      password: '',
+      pairing: { pairUrl: 'https://kitchen.example.com/pair', code: 'pairing-code-0123456789' },
+    })
+  })
+
+  it('rejects an invalid pairing link with an inline error', async () => {
+    const user = userEvent.setup()
+    renderDialog()
+
+    await user.type(screen.getByLabelText('Pairing link'), 'not-a-pairing-link')
+    await user.click(screen.getByRole('button', { name: 'Use link' }))
+
+    expect(screen.getByRole('alert')).toHaveTextContent('That is not a valid OpenCode pairing link.')
+    expect(screen.queryByText(/Pairing with/)).not.toBeInTheDocument()
+  })
+
+  it('explains that a pairing link from an unsupported version cannot be used', async () => {
+    const user = userEvent.setup()
+    renderDialog()
+
+    const outdated = pairingLink.replace(`v=${OPENCODE_SERVER_LINK_VERSION}`, 'v=1')
+    await user.type(screen.getByLabelText('Pairing link'), outdated)
+    await user.click(screen.getByRole('button', { name: 'Use link' }))
+
+    expect(screen.getByRole('alert')).toHaveTextContent(
+      `This pairing link uses link version 1, but this Manager expects version ${OPENCODE_SERVER_LINK_VERSION}. Update the Manager or the ocm CLI and generate a new QR code.`,
+    )
+    expect(screen.queryByText(/Pairing with/)).not.toBeInTheDocument()
+  })
+
+  it('sends clearPassword when the stored password is explicitly cleared', async () => {
+    const user = userEvent.setup()
+    const { onSubmit } = renderDialog({ server: savedServer })
+
+    expect(screen.getByLabelText('Password')).toHaveValue('')
+
+    await user.click(screen.getByLabelText('Clear stored password'))
+    await user.click(screen.getByRole('button', { name: 'Save changes' }))
+
+    await waitFor(() => expect(onSubmit).toHaveBeenCalledTimes(1))
+    expect(onSubmit.mock.calls[0][0]).toMatchObject({
+      name: 'Office',
+      baseUrl: 'https://office.example.com',
+      clearPassword: true,
+      pairing: null,
+    })
+  })
+
+  it('shows the connection test result from the parent', async () => {
+    const user = userEvent.setup()
+    const { onTest } = renderDialog({ server: savedServer })
+
+    await user.click(screen.getByRole('button', { name: 'Test connection' }))
+
+    await waitFor(() => expect(onTest).toHaveBeenCalledTimes(1))
+    expect(await screen.findByText('Connected — OpenCode 2.0.15')).toBeInTheDocument()
+    expect(screen.getByText('Supported')).toBeInTheDocument()
+  })
+
+  it('warns that changing the server origin requires credentials', async () => {
+    const user = userEvent.setup()
+    renderDialog({ server: savedServer })
+
+    expect(screen.queryByText(originChangeWarning)).not.toBeInTheDocument()
+
+    await user.clear(screen.getByLabelText('URL'))
+    await user.type(screen.getByLabelText('URL'), 'https://relocated.example.com')
+
+    expect(screen.getByText(originChangeWarning)).toBeInTheDocument()
+  })
+
+  it('does not warn for a same-origin address change', async () => {
+    const user = userEvent.setup()
+    renderDialog({ server: savedServer })
+
+    await user.clear(screen.getByLabelText('URL'))
+    await user.type(screen.getByLabelText('URL'), 'https://office.example.com/api')
+
+    expect(screen.queryByText(originChangeWarning)).not.toBeInTheDocument()
+  })
+
+  it('does not warn once a password is entered for the new origin', async () => {
+    const user = userEvent.setup()
+    renderDialog({ server: savedServer })
+
+    await user.clear(screen.getByLabelText('URL'))
+    await user.type(screen.getByLabelText('URL'), 'https://relocated.example.com')
+    await user.type(screen.getByLabelText('Password'), 'new-password')
+
+    expect(screen.queryByText(originChangeWarning)).not.toBeInTheDocument()
+  })
+
+  it('does not warn about an origin change when no password is stored', async () => {
+    const user = userEvent.setup()
+    renderDialog({ server: { ...savedServer, hasPassword: false } })
+
+    await user.clear(screen.getByLabelText('URL'))
+    await user.type(screen.getByLabelText('URL'), 'https://relocated.example.com')
+
+    expect(screen.queryByText(originChangeWarning)).not.toBeInTheDocument()
+  })
+})
diff --git a/frontend/src/components/settings/OpenCodeServerDialog.tsx b/frontend/src/components/settings/OpenCodeServerDialog.tsx
new file mode 100644
index 000000000..8c22a20ff
--- /dev/null
+++ b/frontend/src/components/settings/OpenCodeServerDialog.tsx
@@ -0,0 +1,467 @@
+import { useEffect, useState } from 'react'
+import { useForm } from 'react-hook-form'
+import { zodResolver } from '@hookform/resolvers/zod'
+import { z } from 'zod'
+import { AlertTriangle, CheckCircle2, Loader2, ScanLine, XCircle } from 'lucide-react'
+import {
+  OPENCODE_SERVER_LINK_VERSION,
+  OPENCODE_SERVER_USERNAME,
+  parseOpenCodeServerLink,
+  readOpenCodeServerLinkVersion,
+  type OpenCodeServer,
+  type OpenCodeServerLink,
+  type OpenCodeServerTestResult,
+} from '@opencode-manager/shared/schemas'
+import { haveSameUrlOrigin } from '@opencode-manager/shared/utils'
+import { Badge } from '@/components/ui/badge'
+import { Button } from '@/components/ui/button'
+import { Checkbox } from '@/components/ui/checkbox'
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from '@/components/ui/dialog'
+import {
+  Form,
+  FormControl,
+  FormDescription,
+  FormField,
+  FormItem,
+  FormLabel,
+  FormMessage,
+} from '@/components/ui/form'
+import { Input } from '@/components/ui/input'
+import { Label } from '@/components/ui/label'
+import { Switch } from '@/components/ui/switch'
+import { Textarea } from '@/components/ui/textarea'
+import { QrCodeScanner } from './QrCodeScanner'
+
+export interface OpenCodeServerFormValues {
+  name: string
+  baseUrl: string
+  username: string
+  password: string
+  enabled: boolean
+  clearPassword: boolean
+  pairing: OpenCodeServerLink['pairing'] | null
+}
+
+interface OpenCodeServerDialogProps {
+  open: boolean
+  onOpenChange: (open: boolean) => void
+  server?: OpenCodeServer | null
+  onSubmit: (values: OpenCodeServerFormValues) => Promise<void>
+  onTest: (values: OpenCodeServerFormValues) => Promise<OpenCodeServerTestResult>
+}
+
+function isHttpUrl(value: string): boolean {
+  try {
+    const url = new URL(value)
+    return (url.protocol === 'http:' || url.protocol === 'https:') && url.hostname.length > 0
+  } catch {
+    return false
+  }
+}
+
+const serverFormSchema = z.object({
+  name: z.string().trim().min(1, 'Name is required').max(100, 'Name must be 100 characters or fewer'),
+  baseUrl: z
+    .string()
+    .trim()
+    .min(1, 'URL is required')
+    .refine(isHttpUrl, 'Enter a URL starting with http:// or https://'),
+  username: z
+    .string()
+    .trim()
+    .min(1, 'Username is required')
+    .max(100, 'Username must be 100 characters or fewer'),
+  password: z.string().max(1024, 'Password is too long'),
+  enabled: z.boolean(),
+})
+
+type ServerFormValues = z.infer<typeof serverFormSchema>
+
+function isPrivateHost(hostname: string): boolean {
+  const host = hostname.toLowerCase()
+  if (host === 'localhost' || host === '127.0.0.1' || host === '::1' || host === '[::1]') return true
+  const octets = host.split('.').map((part) => Number(part))
+  if (octets.length !== 4 || octets.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) {
+    return false
+  }
+  const [first, second] = octets
+  return (
+    first === 10 ||
+    (first === 172 && second >= 16 && second <= 31) ||
+    (first === 192 && second === 168) ||
+    (first === 169 && second === 254)
+  )
+}
+
+function sendsCredentialsInClear(baseUrl: string): boolean {
+  try {
+    const url = new URL(baseUrl)
+    return url.protocol === 'http:' && !isPrivateHost(url.hostname)
+  } catch {
+    return false
+  }
+}
+
+function buildDefaultValues(server?: OpenCodeServer | null): ServerFormValues {
+  return {
+    name: server?.name ?? '',
+    baseUrl: server?.baseUrl ?? '',
+    username: server?.username ?? OPENCODE_SERVER_USERNAME,
+    password: '',
+    enabled: server?.enabled ?? true,
+  }
+}
+
+function TestResultSummary({ result }: { result: OpenCodeServerTestResult }) {
+  if (!result.ok) {
+    return (
+      <div role="status" className="flex items-start gap-2 rounded-md border border-destructive/40 p-2 text-sm text-destructive">
+        <XCircle className="mt-0.5 h-4 w-4 shrink-0" />
+        <span className="break-words">{result.error ?? 'Connection failed'}</span>
+      </div>
+    )
+  }
+  return (
+    <div role="status" className="flex flex-wrap items-center gap-2 rounded-md border border-border p-2 text-sm">
+      <CheckCircle2 className="h-4 w-4 shrink-0 text-success" />
+      <span>Connected — OpenCode {result.version ?? 'unknown version'}</span>
+      {result.versionSupported ? (
+        <Badge variant="secondary">Supported</Badge>
+      ) : (
+        <Badge variant="destructive">Unsupported version</Badge>
+      )}
+    </div>
+  )
+}
+
+export function OpenCodeServerDialog({
+  open,
+  onOpenChange,
+  server,
+  onSubmit,
+  onTest,
+}: OpenCodeServerDialogProps) {
+  const form = useForm<ServerFormValues>({
+    resolver: zodResolver(serverFormSchema),
+    defaultValues: buildDefaultValues(server),
+  })
+  const [pairingLink, setPairingLink] = useState<OpenCodeServerLink | null>(null)
+  const [linkInput, setLinkInput] = useState('')
+  const [linkError, setLinkError] = useState<string | null>(null)
+  const [isScannerOpen, setIsScannerOpen] = useState(false)
+  const [clearPassword, setClearPassword] = useState(false)
+  const [testResult, setTestResult] = useState<OpenCodeServerTestResult | null>(null)
+  const [testError, setTestError] = useState<string | null>(null)
+  const [isTesting, setIsTesting] = useState(false)
+
+  useEffect(() => {
+    if (!open) return
+    form.reset(buildDefaultValues(server))
+    setPairingLink(null)
+    setLinkInput('')
+    setLinkError(null)
+    setClearPassword(false)
+    setTestResult(null)
+    setTestError(null)
+  }, [open, server, form])
+
+  const baseUrlValue = form.watch('baseUrl')
+  const passwordValue = form.watch('password')
+  const transportWarning = sendsCredentialsInClear(baseUrlValue)
+  const isEditing = Boolean(server)
+  const originChanged = Boolean(
+    server && isHttpUrl(baseUrlValue) && !haveSameUrlOrigin(server.baseUrl, baseUrlValue),
+  )
+  const needsCredentialsForOriginChange =
+    Boolean(server?.hasPassword) && originChanged && !passwordValue && !clearPassword && !pairingLink
+  const isSubmitting = form.formState.isSubmitting
+
+  const applyPairingLink = (text: string) => {
+    const link = parseOpenCodeServerLink(text)
+    if (!link) {
+      const version = readOpenCodeServerLinkVersion(text)
+      setLinkError(version !== null && version !== OPENCODE_SERVER_LINK_VERSION
+        ? `This pairing link uses link version ${version}, but this Manager expects version ${OPENCODE_SERVER_LINK_VERSION}. Update the Manager or the ocm CLI and generate a new QR code.`
+        : 'That is not a valid OpenCode pairing link.')
+      return
+    }
+    setPairingLink(link)
+    setLinkInput(text.trim())
+    setLinkError(null)
+    setTestResult(null)
+    setTestError(null)
+    form.setValue('name', link.name, { shouldValidate: true })
+    form.setValue('baseUrl', link.baseUrl, { shouldValidate: true })
+  }
+
+  const clearPairing = () => {
+    setPairingLink(null)
+    setLinkInput('')
+    setLinkError(null)
+  }
+
+  const collectValues = (): OpenCodeServerFormValues => ({
+    ...form.getValues(),
+    clearPassword,
+    pairing: pairingLink?.pairing ?? null,
+  })
+
+  const handleTest = async () => {
+    const isValid = await form.trigger(['baseUrl', 'username'])
+    if (!isValid) return
+    setIsTesting(true)
+    setTestError(null)
+    setTestResult(null)
+    try {
+      setTestResult(await onTest(collectValues()))
+    } catch (error) {
+      setTestError(error instanceof Error ? error.message : 'Connection test failed')
+    } finally {
+      setIsTesting(false)
+    }
+  }
+
+  const handleSubmit = form.handleSubmit(async (values) => {
+    try {
+      await onSubmit({ ...values, clearPassword, pairing: pairingLink?.pairing ?? null })
+      onOpenChange(false)
+    } catch (error) {
+      form.setError('root', {
+        message: error instanceof Error ? error.message : 'Failed to save the server',
+      })
+    }
+  })
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent mobileFullscreen className="sm:max-w-2xl sm:max-h-[85vh] gap-0 flex flex-col p-0 md:p-6">
+        <DialogHeader className="border-b p-4 sm:p-6">
+          <DialogTitle>{isEditing ? 'Edit server' : 'Add server'}</DialogTitle>
+          <DialogDescription>
+            Link a remote OpenCode server so its sessions appear in this Manager.
+          </DialogDescription>
+        </DialogHeader>
+
+        <div className="flex-1 overflow-y-auto p-4 sm:p-6">
+          <Form {...form}>
+            <div className="space-y-4">
+              {!isEditing && (
+                <section className="space-y-3 rounded-lg border border-border p-3">
+                  <div className="flex flex-wrap items-center justify-between gap-2">
+                    <div>
+                      <p className="text-sm font-medium">Pair from QR code</p>
+                      <p className="text-xs text-muted-foreground">
+                        Scan the code shown by the server, or paste its pairing link.
+                      </p>
+                    </div>
+                    <Button type="button" variant="outline" size="sm" onClick={() => setIsScannerOpen(true)}>
+                      <ScanLine className="mr-2 h-4 w-4" />
+                      Scan QR
+                    </Button>
+                  </div>
+
+                  <div className="space-y-2">
+                    <Label htmlFor="pairing-link">Pairing link</Label>
+                    <Textarea
+                      id="pairing-link"
+                      value={linkInput}
+                      onChange={(event) => {
+                        setLinkInput(event.target.value)
+                        setLinkError(null)
+                      }}
+                      placeholder={`ocm://link?v=${OPENCODE_SERVER_LINK_VERSION}&kind=opencode&...`}
+                      rows={2}
+                      className="font-mono"
+                    />
+                    <div className="flex flex-wrap items-center gap-2">
+                      <Button
+                        type="button"
+                        variant="outline"
+                        size="sm"
+                        onClick={() => applyPairingLink(linkInput)}
+                        disabled={!linkInput.trim()}
+                      >
+                        Use link
+                      </Button>
+                      {pairingLink && (
+                        <>
+                          <Badge variant="secondary">Pairing with {pairingLink.name}</Badge>
+                          <Button type="button" variant="ghost" size="sm" onClick={clearPairing}>
+                            Clear
+                          </Button>
+                        </>
+                      )}
+                    </div>
+                    {linkError && (
+                      <p role="alert" className="text-sm text-destructive">
+                        {linkError}
+                      </p>
+                    )}
+                  </div>
+                </section>
+              )}
+
+              <FormField
+                control={form.control}
+                name="name"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>Name</FormLabel>
+                    <FormControl>
+                      <Input {...field} placeholder="Kitchen workstation" />
+                    </FormControl>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+
+              <FormField
+                control={form.control}
+                name="baseUrl"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>URL</FormLabel>
+                    <FormControl>
+                      <Input {...field} placeholder="https://opencode.example.com" className="font-mono" />
+                    </FormControl>
+                    <FormDescription>The base URL of the remote OpenCode server.</FormDescription>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+
+              {transportWarning && (
+                <div className="flex items-start gap-2 rounded-md border border-warning/40 p-2 text-sm text-warning">
+                  <AlertTriangle className="mt-0.5 h-4 w-4 shrink-0" />
+                  <span>
+                    This URL is not HTTPS, so credentials travel unencrypted. Use HTTPS unless the server is on a
+                    private network.
+                  </span>
+                </div>
+              )}
+
+              <FormField
+                control={form.control}
+                name="username"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>Username</FormLabel>
+                    <FormControl>
+                      <Input {...field} autoComplete="username" />
+                    </FormControl>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+
+              {!pairingLink && (
+                <div className="space-y-3">
+                  <FormField
+                    control={form.control}
+                    name="password"
+                    render={({ field }) => (
+                      <FormItem>
+                        <FormLabel>Password</FormLabel>
+                        <FormControl>
+                          <Input
+                            {...field}
+                            type="password"
+                            autoComplete="new-password"
+                            disabled={clearPassword}
+                            placeholder={isEditing ? 'Leave blank to keep the current password' : 'Server password'}
+                          />
+                        </FormControl>
+                        <FormDescription>
+                          {isEditing
+                            ? 'Leave blank to keep the current password.'
+                            : 'Password used to authenticate with the remote server.'}
+                        </FormDescription>
+                        <FormMessage />
+                      </FormItem>
+                    )}
+                  />
+
+                  {needsCredentialsForOriginChange && (
+                    <div role="status" className="flex items-start gap-2 rounded-md border border-warning/40 p-2 text-sm text-warning">
+                      <AlertTriangle className="mt-0.5 h-4 w-4 shrink-0" />
+                      <span>Changing the server address requires re-entering the password or pairing again.</span>
+                    </div>
+                  )}
+
+                  {isEditing && server?.hasPassword && (
+                    <div className="flex items-center gap-2">
+                      <Checkbox
+                        id="clear-password"
+                        checked={clearPassword}
+                        onCheckedChange={(checked) => setClearPassword(checked === true)}
+                      />
+                      <Label htmlFor="clear-password" className="font-normal">
+                        Clear stored password
+                      </Label>
+                    </div>
+                  )}
+                </div>
+              )}
+
+              <FormField
+                control={form.control}
+                name="enabled"
+                render={({ field }) => (
+                  <FormItem className="flex flex-row items-center justify-between rounded-lg border border-border p-3">
+                    <div className="space-y-0.5">
+                      <FormLabel>Enabled</FormLabel>
+                      <FormDescription>Connect to this server when the Manager starts.</FormDescription>
+                    </div>
+                    <FormControl>
+                      <Switch checked={field.value} onCheckedChange={field.onChange} aria-label="Enabled" />
+                    </FormControl>
+                  </FormItem>
+                )}
+              />
+
+              {!pairingLink && (
+                <div className="space-y-2">
+                  <Button type="button" variant="outline" size="sm" onClick={handleTest} disabled={isTesting}>
+                    {isTesting && <Loader2 className="mr-2 h-4 w-4 animate-spin" />}
+                    Test connection
+                  </Button>
+                  {testResult && <TestResultSummary result={testResult} />}
+                  {testError && (
+                    <p role="alert" className="text-sm text-destructive">
+                      {testError}
+                    </p>
+                  )}
+                </div>
+              )}
+
+              {form.formState.errors.root?.message && (
+                <p role="alert" className="text-sm text-destructive">
+                  {form.formState.errors.root.message}
+                </p>
+              )}
+            </div>
+          </Form>
+        </div>
+
+        <DialogFooter className="gap-2 border-t p-3 pb-4 sm:p-4">
+          <Button variant="outline" onClick={() => onOpenChange(false)} className="flex-1 sm:flex-none">
+            Cancel
+          </Button>
+          <Button onClick={() => void handleSubmit()} disabled={isSubmitting} className="flex-1 sm:flex-none">
+            {isSubmitting && <Loader2 className="mr-2 h-4 w-4 animate-spin" />}
+            {isEditing ? 'Save changes' : 'Add server'}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+
+      <QrCodeScanner open={isScannerOpen} onOpenChange={setIsScannerOpen} onResult={applyPairingLink} />
+    </Dialog>
+  )
+}
diff --git a/frontend/src/components/settings/OpenCodeServersSettings.test.tsx b/frontend/src/components/settings/OpenCodeServersSettings.test.tsx
new file mode 100644
index 000000000..4cf0d3f92
--- /dev/null
+++ b/frontend/src/components/settings/OpenCodeServersSettings.test.tsx
@@ -0,0 +1,114 @@
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
+import { render, screen } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+import type { OpenCodeServer, OpenCodeServerTestResult } from '@opencode-manager/shared/schemas'
+import { OpenCodeServersSettings } from './OpenCodeServersSettings'
+
+const testResult: OpenCodeServerTestResult = {
+  ok: true,
+  version: '2.0.15',
+  versionSupported: true,
+  error: null,
+}
+
+const savedServer: OpenCodeServer = {
+  id: 'srv_1',
+  name: 'Office',
+  baseUrl: 'https://office.example.com',
+  username: 'opencode',
+  enabled: true,
+  hasPassword: true,
+  createdAt: 1,
+  updatedAt: 2,
+}
+
+const mocks = vi.hoisted(() => ({
+  servers: [] as OpenCodeServer[],
+  testAsync: vi.fn(),
+  testByIdAsync: vi.fn(),
+}))
+
+vi.mock('@/hooks/useOpenCodeServers', () => ({
+  useOpenCodeServers: () => ({
+    servers: mocks.servers,
+    isLoading: false,
+    error: null,
+    refetch: vi.fn(),
+    createAsync: vi.fn(),
+    isCreating: false,
+    updateAsync: vi.fn(),
+    isUpdating: false,
+    deleteAsync: vi.fn(),
+    isDeleting: false,
+    testAsync: mocks.testAsync,
+    testByIdAsync: mocks.testByIdAsync,
+  }),
+}))
+
+async function openEditDialog() {
+  const user = userEvent.setup()
+  render(<OpenCodeServersSettings />)
+  await user.click(screen.getByRole('button', { name: 'Edit Office' }))
+  return user
+}
+
+describe('OpenCodeServersSettings', () => {
+  beforeAll(() => {
+    Element.prototype.hasPointerCapture ??= () => false
+    Element.prototype.setPointerCapture ??= () => {}
+    Element.prototype.releasePointerCapture ??= () => {}
+    Element.prototype.scrollIntoView ??= () => {}
+  })
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mocks.servers = [savedServer]
+    mocks.testAsync.mockResolvedValue(testResult)
+    mocks.testByIdAsync.mockResolvedValue(testResult)
+  })
+
+  it('tests the draft with the saved server id when the password is left blank', async () => {
+    const user = await openEditDialog()
+
+    await user.click(screen.getByRole('button', { name: 'Test connection' }))
+
+    expect(mocks.testAsync).toHaveBeenCalledWith({
+      baseUrl: 'https://office.example.com',
+      username: 'opencode',
+      password: undefined,
+      serverId: 'srv_1',
+    })
+    expect(mocks.testByIdAsync).not.toHaveBeenCalled()
+  })
+
+  it('tests the edited address with the saved server id', async () => {
+    const user = await openEditDialog()
+
+    await user.clear(screen.getByLabelText('URL'))
+    await user.type(screen.getByLabelText('URL'), 'https://relocated.example.com')
+    await user.click(screen.getByRole('button', { name: 'Test connection' }))
+
+    expect(mocks.testAsync).toHaveBeenCalledWith({
+      baseUrl: 'https://relocated.example.com',
+      username: 'opencode',
+      password: undefined,
+      serverId: 'srv_1',
+    })
+    expect(mocks.testByIdAsync).not.toHaveBeenCalled()
+  })
+
+  it('tests the edited address without the saved server id when the stored password is being cleared', async () => {
+    const user = await openEditDialog()
+
+    await user.click(screen.getByLabelText('Clear stored password'))
+    await user.click(screen.getByRole('button', { name: 'Test connection' }))
+
+    expect(mocks.testAsync).toHaveBeenCalledWith({
+      baseUrl: 'https://office.example.com',
+      username: 'opencode',
+      password: undefined,
+      serverId: undefined,
+    })
+    expect(mocks.testByIdAsync).not.toHaveBeenCalled()
+  })
+})
diff --git a/frontend/src/components/settings/OpenCodeServersSettings.tsx b/frontend/src/components/settings/OpenCodeServersSettings.tsx
new file mode 100644
index 000000000..e0084ab3e
--- /dev/null
+++ b/frontend/src/components/settings/OpenCodeServersSettings.tsx
@@ -0,0 +1,276 @@
+import { useState } from 'react'
+import { Activity, AlertCircle, CheckCircle2, Loader2, Pencil, Plus, Trash2, XCircle } from 'lucide-react'
+import type {
+  CreateOpenCodeServerRequest,
+  OpenCodeServer,
+  OpenCodeServerTestResult,
+  UpdateOpenCodeServerRequest,
+} from '@opencode-manager/shared/schemas'
+import { Badge } from '@/components/ui/badge'
+import { Button } from '@/components/ui/button'
+import { Switch } from '@/components/ui/switch'
+import { DeleteDialog } from '@/components/ui/delete-dialog'
+import { showToast } from '@/lib/toast'
+import { useOpenCodeServers } from '@/hooks/useOpenCodeServers'
+import { OpenCodeServerDialog, type OpenCodeServerFormValues } from './OpenCodeServerDialog'
+
+function errorMessage(error: unknown, fallback: string): string {
+  return error instanceof Error && error.message ? error.message : fallback
+}
+
+function ServerTestResult({ result }: { result: OpenCodeServerTestResult }) {
+  if (!result.ok) {
+    return (
+      <div className="flex items-start gap-2 text-sm text-destructive">
+        <XCircle className="mt-0.5 h-4 w-4 shrink-0" />
+        <span className="break-words">{result.error ?? 'Connection failed'}</span>
+      </div>
+    )
+  }
+  return (
+    <div className="flex flex-wrap items-center gap-2 text-sm">
+      <CheckCircle2 className="h-4 w-4 shrink-0 text-success" />
+      <span>OpenCode {result.version ?? 'unknown version'}</span>
+      {result.versionSupported ? (
+        <Badge variant="secondary">Supported</Badge>
+      ) : (
+        <Badge variant="destructive">Unsupported version</Badge>
+      )}
+    </div>
+  )
+}
+
+export function OpenCodeServersSettings() {
+  const {
+    servers,
+    isLoading,
+    error,
+    createAsync,
+    isCreating,
+    updateAsync,
+    isUpdating,
+    deleteAsync,
+    isDeleting,
+    testAsync,
+    testByIdAsync,
+  } = useOpenCodeServers()
+  const [isDialogOpen, setIsDialogOpen] = useState(false)
+  const [editingServer, setEditingServer] = useState<OpenCodeServer | null>(null)
+  const [deletingServer, setDeletingServer] = useState<OpenCodeServer | null>(null)
+  const [testingServerId, setTestingServerId] = useState<string | null>(null)
+  const [testResults, setTestResults] = useState<Record<string, OpenCodeServerTestResult>>({})
+
+  const openAddDialog = () => {
+    setEditingServer(null)
+    setIsDialogOpen(true)
+  }
+
+  const openEditDialog = (server: OpenCodeServer) => {
+    setEditingServer(server)
+    setIsDialogOpen(true)
+  }
+
+  const handleDialogOpenChange = (open: boolean) => {
+    setIsDialogOpen(open)
+    if (!open) setEditingServer(null)
+  }
+
+  const handleSubmit = async (values: OpenCodeServerFormValues) => {
+    if (editingServer) {
+      const input: UpdateOpenCodeServerRequest = {
+        name: values.name,
+        baseUrl: values.baseUrl,
+        username: values.username,
+        enabled: values.enabled,
+      }
+      if (values.pairing) input.pairing = values.pairing
+      else if (values.clearPassword) input.password = null
+      else if (values.password) input.password = values.password
+      await updateAsync({ id: editingServer.id, input })
+      showToast.success('Server updated')
+      return
+    }
+
+    const input: CreateOpenCodeServerRequest = {
+      name: values.name,
+      baseUrl: values.baseUrl,
+      username: values.username,
+      enabled: values.enabled,
+    }
+    if (values.pairing) input.pairing = values.pairing
+    else if (values.password) input.password = values.password
+    const { test } = await createAsync(input)
+    if (test.ok) {
+      showToast.success(`Server added${test.version ? ` — OpenCode ${test.version}` : ''}`)
+    } else {
+      showToast.warning(`Server added, but the connection test failed: ${test.error ?? 'unknown error'}`)
+    }
+  }
+
+  const handleTest = async (values: OpenCodeServerFormValues) =>
+    testAsync({
+      baseUrl: values.baseUrl,
+      username: values.username,
+      password: values.password || undefined,
+      serverId: editingServer && !values.password && !values.clearPassword ? editingServer.id : undefined,
+    })
+
+  const toggleEnabled = async (server: OpenCodeServer, enabled: boolean) => {
+    try {
+      await updateAsync({ id: server.id, input: { enabled } })
+    } catch (updateError) {
+      showToast.error(errorMessage(updateError, 'Failed to update server'))
+    }
+  }
+
+  const runTest = async (server: OpenCodeServer) => {
+    setTestingServerId(server.id)
+    setTestResults((current) => {
+      const next = { ...current }
+      delete next[server.id]
+      return next
+    })
+    try {
+      const result = await testByIdAsync(server.id)
+      setTestResults((current) => ({ ...current, [server.id]: result }))
+    } catch (testError) {
+      showToast.error(errorMessage(testError, 'Connection test failed'))
+    } finally {
+      setTestingServerId(null)
+    }
+  }
+
+  const confirmDelete = async () => {
+    if (!deletingServer) return
+    try {
+      await deleteAsync(deletingServer.id)
+      showToast.success('Server deleted')
+      setDeletingServer(null)
+    } catch (deleteError) {
+      showToast.error(errorMessage(deleteError, 'Failed to delete server'))
+    }
+  }
+
+  return (
+    <div className="space-y-4">
+      <div className="flex flex-wrap items-start justify-between gap-3">
+        <div>
+          <h2 className="text-lg font-semibold text-foreground">Linked servers</h2>
+          <p className="text-sm text-muted-foreground">
+            Remote OpenCode servers this Manager can connect to. Disabled servers stay configured but are not used.
+          </p>
+        </div>
+        <Button type="button" size="sm" onClick={openAddDialog} disabled={isCreating}>
+          <Plus className="mr-2 h-4 w-4" />
+          Add server
+        </Button>
+      </div>
+
+      {isLoading && (
+        <div className="flex items-center justify-center gap-2 py-10 text-sm text-muted-foreground">
+          <Loader2 className="h-4 w-4 animate-spin" />
+          Loading servers...
+        </div>
+      )}
+
+      {!isLoading && error && (
+        <div className="flex items-start gap-2 rounded-lg border border-destructive/40 p-4 text-sm text-destructive">
+          <AlertCircle className="mt-0.5 h-4 w-4 shrink-0" />
+          <span>{errorMessage(error, 'Failed to load servers')}</span>
+        </div>
+      )}
+
+      {!isLoading && !error && servers.length === 0 && (
+        <div className="rounded-lg border border-dashed border-border p-6 text-center">
+          <p className="text-sm text-muted-foreground">
+            No linked servers. Add one with a pairing QR code or by entering its URL and credentials.
+          </p>
+        </div>
+      )}
+
+      {servers.length > 0 && (
+        <div className="space-y-3">
+          {servers.map((server) => (
+            <div key={server.id} className="space-y-3 rounded-lg border border-border p-4">
+              <div className="flex flex-wrap items-start justify-between gap-3">
+                <div className="min-w-0 space-y-1">
+                  <div className="flex flex-wrap items-center gap-2">
+                    <span className="font-medium text-foreground">{server.name}</span>
+                    <Badge variant={server.hasPassword ? 'secondary' : 'outline'}>
+                      {server.hasPassword ? 'Password set' : 'No password'}
+                    </Badge>
+                    {!server.enabled && <Badge variant="outline">Disabled</Badge>}
+                  </div>
+                  <p className="break-all text-sm text-muted-foreground">{server.baseUrl}</p>
+                  <p className="text-xs text-muted-foreground">Username: {server.username}</p>
+                </div>
+
+                <div className="flex flex-wrap items-center gap-1">
+                  <Switch
+                    checked={server.enabled}
+                    onCheckedChange={(checked) => void toggleEnabled(server, checked)}
+                    disabled={isUpdating}
+                    aria-label={`Enable ${server.name}`}
+                  />
+                  <Button
+                    type="button"
+                    variant="outline"
+                    size="sm"
+                    onClick={() => void runTest(server)}
+                    disabled={testingServerId === server.id}
+                  >
+                    {testingServerId === server.id ? (
+                      <Loader2 className="mr-2 h-4 w-4 animate-spin" />
+                    ) : (
+                      <Activity className="mr-2 h-4 w-4" />
+                    )}
+                    Test
+                  </Button>
+                  <Button
+                    type="button"
+                    variant="ghost"
+                    size="icon"
+                    aria-label={`Edit ${server.name}`}
+                    onClick={() => openEditDialog(server)}
+                  >
+                    <Pencil className="h-4 w-4" />
+                  </Button>
+                  <Button
+                    type="button"
+                    variant="ghost"
+                    size="icon"
+                    aria-label={`Delete ${server.name}`}
+                    onClick={() => setDeletingServer(server)}
+                  >
+                    <Trash2 className="h-4 w-4 text-destructive" />
+                  </Button>
+                </div>
+              </div>
+
+              {testResults[server.id] && <ServerTestResult result={testResults[server.id]} />}
+            </div>
+          ))}
+        </div>
+      )}
+
+      <OpenCodeServerDialog
+        open={isDialogOpen}
+        onOpenChange={handleDialogOpenChange}
+        server={editingServer}
+        onSubmit={handleSubmit}
+        onTest={handleTest}
+      />
+
+      <DeleteDialog
+        open={Boolean(deletingServer)}
+        onOpenChange={(open) => !open && setDeletingServer(null)}
+        onConfirm={() => void confirmDelete()}
+        onCancel={() => setDeletingServer(null)}
+        title="Delete Server"
+        description="Remove this linked server from the Manager. Its sessions stay on the remote server."
+        itemName={deletingServer?.name}
+        isDeleting={isDeleting}
+      />
+    </div>
+  )
+}
diff --git a/frontend/src/components/settings/QrCodeScanner.test.tsx b/frontend/src/components/settings/QrCodeScanner.test.tsx
new file mode 100644
index 000000000..048ed588c
--- /dev/null
+++ b/frontend/src/components/settings/QrCodeScanner.test.tsx
@@ -0,0 +1,120 @@
+import { describe, it, expect, vi, beforeEach, afterEach, beforeAll } from 'vitest'
+import { render, waitFor, act } from '@testing-library/react'
+import { QrCodeScanner } from './QrCodeScanner'
+
+const { decodeMock } = vi.hoisted(() => ({ decodeMock: vi.fn() }))
+
+vi.mock('jsqr', () => ({ default: decodeMock }))
+
+const frameQueue: FrameRequestCallback[] = []
+const requestFrame = vi.fn((callback: FrameRequestCallback) => {
+  frameQueue.push(callback)
+  return frameQueue.length
+})
+const cancelFrame = vi.fn()
+
+const imageDataMock = vi.fn((_x: number, _y: number, width: number, height: number) => ({
+  data: new Uint8ClampedArray(width * height * 4),
+  width,
+  height,
+}))
+
+const contextMock = {
+  drawImage: vi.fn(),
+  getImageData: imageDataMock,
+}
+
+const getUserMediaMock = vi.fn(async () => ({ getTracks: () => [] }))
+const originalGetContext = HTMLCanvasElement.prototype.getContext
+
+async function runFrame(timestamp: number) {
+  await waitFor(() => expect(frameQueue.length).toBeGreaterThan(0))
+  const callback = frameQueue.shift()
+  await act(async () => {
+    callback?.(timestamp)
+  })
+}
+
+function renderScanner() {
+  return render(<QrCodeScanner open onOpenChange={vi.fn()} onResult={vi.fn()} />)
+}
+
+describe('QrCodeScanner', () => {
+  beforeAll(() => {
+    Object.defineProperty(HTMLMediaElement.prototype, 'play', {
+      configurable: true,
+      value: () => Promise.resolve(),
+    })
+    Object.defineProperty(HTMLMediaElement.prototype, 'readyState', {
+      configurable: true,
+      get: () => 4,
+    })
+    Object.defineProperty(HTMLVideoElement.prototype, 'videoWidth', {
+      configurable: true,
+      get: () => 1280,
+    })
+    Object.defineProperty(HTMLVideoElement.prototype, 'videoHeight', {
+      configurable: true,
+      get: () => 720,
+    })
+    Object.defineProperty(window, 'isSecureContext', {
+      configurable: true,
+      value: true,
+    })
+  })
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    frameQueue.length = 0
+    decodeMock.mockReturnValue(null)
+    HTMLCanvasElement.prototype.getContext = vi.fn(
+      () => contextMock,
+    ) as unknown as HTMLCanvasElement['getContext']
+    Object.defineProperty(navigator, 'mediaDevices', {
+      configurable: true,
+      value: { getUserMedia: getUserMediaMock },
+    })
+    vi.stubGlobal('requestAnimationFrame', requestFrame)
+    vi.stubGlobal('cancelAnimationFrame', cancelFrame)
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+    HTMLCanvasElement.prototype.getContext = originalGetContext
+  })
+
+  it('decodes at most once per 100ms of animation frames', async () => {
+    renderScanner()
+
+    await runFrame(100)
+    expect(decodeMock).toHaveBeenCalledTimes(1)
+
+    await runFrame(130)
+    await runFrame(160)
+    await runFrame(190)
+    expect(decodeMock).toHaveBeenCalledTimes(1)
+
+    await runFrame(200)
+    expect(decodeMock).toHaveBeenCalledTimes(2)
+  })
+
+  it('only resizes the canvas when the scan dimensions change', async () => {
+    const widthSetter = vi.spyOn(HTMLCanvasElement.prototype, 'width', 'set')
+    const heightSetter = vi.spyOn(HTMLCanvasElement.prototype, 'height', 'set')
+
+    renderScanner()
+
+    await runFrame(100)
+    expect(widthSetter).toHaveBeenCalledTimes(1)
+    expect(heightSetter).toHaveBeenCalledTimes(1)
+    expect(imageDataMock).toHaveBeenNthCalledWith(1, 0, 0, 640, 360)
+
+    await runFrame(250)
+    expect(widthSetter).toHaveBeenCalledTimes(1)
+    expect(heightSetter).toHaveBeenCalledTimes(1)
+    expect(imageDataMock).toHaveBeenNthCalledWith(2, 0, 0, 640, 360)
+
+    widthSetter.mockRestore()
+    heightSetter.mockRestore()
+  })
+})
diff --git a/frontend/src/components/settings/QrCodeScanner.tsx b/frontend/src/components/settings/QrCodeScanner.tsx
new file mode 100644
index 000000000..8e52a4676
--- /dev/null
+++ b/frontend/src/components/settings/QrCodeScanner.tsx
@@ -0,0 +1,220 @@
+import { useEffect, useRef, useState } from 'react'
+import { AlertCircle, Loader2 } from 'lucide-react'
+import { Button } from '@/components/ui/button'
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from '@/components/ui/dialog'
+
+const MAX_SCAN_DIMENSION = 640
+const DECODE_INTERVAL_MS = 100
+
+type QrDecoder = typeof import('jsqr')['default']
+
+interface QrCodeScannerProps {
+  open: boolean
+  onOpenChange: (open: boolean) => void
+  onResult: (text: string) => void
+}
+
+function describeCameraError(error: unknown): string {
+  if (error instanceof DOMException) {
+    if (error.name === 'NotAllowedError' || error.name === 'SecurityError') {
+      return 'Camera permission was denied. Allow camera access for this site or paste the pairing link instead.'
+    }
+    if (error.name === 'NotFoundError' || error.name === 'OverconstrainedError') {
+      return 'No camera was found on this device. Paste the pairing link instead.'
+    }
+    if (error.name === 'NotReadableError') {
+      return 'The camera is already in use by another application. Paste the pairing link instead.'
+    }
+  }
+  return 'The camera could not be started. Paste the pairing link instead.'
+}
+
+function fitScanDimensions(width: number, height: number): { width: number; height: number } {
+  const longest = Math.max(width, height)
+  if (longest <= MAX_SCAN_DIMENSION) {
+    return { width, height }
+  }
+  const scale = MAX_SCAN_DIMENSION / longest
+  return { width: Math.round(width * scale), height: Math.round(height * scale) }
+}
+
+export function QrCodeScanner({ open, onOpenChange, onResult }: QrCodeScannerProps) {
+  const videoRef = useRef<HTMLVideoElement>(null)
+  const decoderRef = useRef<QrDecoder | null>(null)
+  const onResultRef = useRef(onResult)
+  onResultRef.current = onResult
+  const [error, setError] = useState<string | null>(null)
+  const [isStarting, setIsStarting] = useState(false)
+
+  useEffect(() => {
+    if (!open) return
+    setError(null)
+    setIsStarting(true)
+
+    let stream: MediaStream | null = null
+    let frameId: number | null = null
+    let cancelled = false
+    let decoded = false
+    let lastDecodeAt = Number.NEGATIVE_INFINITY
+    let canvasWidth = 0
+    let canvasHeight = 0
+    const canvas = document.createElement('canvas')
+    const context = canvas.getContext('2d', { willReadFrequently: true })
+
+    const stopCamera = () => {
+      if (frameId !== null) {
+        cancelAnimationFrame(frameId)
+        frameId = null
+      }
+      stream?.getTracks().forEach((track) => track.stop())
+      stream = null
+    }
+
+    const scanFrame = (timestamp: number) => {
+      if (cancelled || decoded) return
+      if (timestamp - lastDecodeAt < DECODE_INTERVAL_MS) {
+        frameId = requestAnimationFrame(scanFrame)
+        return
+      }
+      const video = videoRef.current
+      const decoder = decoderRef.current
+      if (!video || !context || !decoder || video.readyState < video.HAVE_ENOUGH_DATA) {
+        frameId = requestAnimationFrame(scanFrame)
+        return
+      }
+      const size = fitScanDimensions(video.videoWidth, video.videoHeight)
+      if (size.width < 1 || size.height < 1) {
+        frameId = requestAnimationFrame(scanFrame)
+        return
+      }
+      lastDecodeAt = timestamp
+      if (size.width !== canvasWidth || size.height !== canvasHeight) {
+        canvas.width = size.width
+        canvas.height = size.height
+        canvasWidth = size.width
+        canvasHeight = size.height
+      }
+      context.drawImage(video, 0, 0, size.width, size.height)
+      const imageData = context.getImageData(0, 0, size.width, size.height)
+      const code = decoder(imageData.data, imageData.width, imageData.height, {
+        inversionAttempts: 'dontInvert',
+      })
+      if (code?.data) {
+        decoded = true
+        stopCamera()
+        onResultRef.current(code.data)
+        onOpenChange(false)
+        return
+      }
+      frameId = requestAnimationFrame(scanFrame)
+    }
+
+    const loadDecoder = async (): Promise<QrDecoder> => {
+      if (!decoderRef.current) {
+        const module = await import('jsqr')
+        decoderRef.current = module.default
+      }
+      return decoderRef.current
+    }
+
+    const startCamera = async () => {
+      if (!navigator.mediaDevices?.getUserMedia) {
+        setError('Camera access is not available in this browser. Paste the pairing link instead.')
+        setIsStarting(false)
+        return
+      }
+      if (!window.isSecureContext) {
+        setError('Camera access requires a secure (HTTPS) connection. Paste the pairing link instead.')
+        setIsStarting(false)
+        return
+      }
+      try {
+        await loadDecoder()
+      } catch {
+        if (cancelled) return
+        setError('The QR decoder could not be loaded. Paste the pairing link instead.')
+        setIsStarting(false)
+        return
+      }
+      if (cancelled) return
+      try {
+        stream = await navigator.mediaDevices.getUserMedia({
+          video: { facingMode: 'environment' },
+        })
+        if (cancelled) {
+          stream.getTracks().forEach((track) => track.stop())
+          return
+        }
+        const video = videoRef.current
+        if (!video) return
+        video.srcObject = stream
+        await video.play()
+        if (cancelled) return
+        setIsStarting(false)
+        frameId = requestAnimationFrame(scanFrame)
+      } catch (cameraError) {
+        if (cancelled) return
+        setError(describeCameraError(cameraError))
+        setIsStarting(false)
+      }
+    }
+
+    void startCamera()
+
+    return () => {
+      cancelled = true
+      stopCamera()
+    }
+  }, [open, onOpenChange])
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="sm:max-w-md">
+        <DialogHeader>
+          <DialogTitle>Scan pairing QR code</DialogTitle>
+          <DialogDescription>
+            Point the camera at the QR code shown by the OpenCode server you want to link.
+          </DialogDescription>
+        </DialogHeader>
+
+        <div className="space-y-3">
+          <div className="relative aspect-square w-full overflow-hidden rounded-lg border border-border bg-black">
+            <video
+              ref={videoRef}
+              className="h-full w-full object-cover"
+              aria-label="QR code scanner preview"
+              muted
+              playsInline
+            />
+            {isStarting && !error && (
+              <div className="absolute inset-0 flex items-center justify-center gap-2 bg-black/60 text-sm text-white">
+                <Loader2 className="h-4 w-4 animate-spin" />
+                Starting camera...
+              </div>
+            )}
+          </div>
+
+          {error && (
+            <div role="alert" className="flex items-start gap-2 text-sm text-destructive">
+              <AlertCircle className="mt-0.5 h-4 w-4 shrink-0" />
+              <span>{error}</span>
+            </div>
+          )}
+        </div>
+
+        <DialogFooter>
+          <Button variant="outline" onClick={() => onOpenChange(false)}>
+            Close
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  )
+}
diff --git a/frontend/src/components/settings/SettingsDialog.test.tsx b/frontend/src/components/settings/SettingsDialog.test.tsx
index b32eb2f3d..c25707402 100644
--- a/frontend/src/components/settings/SettingsDialog.test.tsx
+++ b/frontend/src/components/settings/SettingsDialog.test.tsx
@@ -310,8 +310,8 @@ describe('SettingsDialog', () => {
     expect(tablist).toHaveAttribute('aria-orientation', 'vertical')
 
     const triggers = screen.getAllByRole('tab')
-    expect(triggers).toHaveLength(9)
-    const expected = ['Account', 'General Settings', 'Notifications', 'Voice', 'Git', 'Keyboard Shortcuts', 'OpenCode Config', 'Logs', 'Providers']
+    expect(triggers).toHaveLength(10)
+    const expected = ['Account', 'General Settings', 'Notifications', 'Voice', 'Git', 'Keyboard Shortcuts', 'Servers', 'OpenCode Config', 'Logs', 'Providers']
     expect(triggers.map((trigger) => trigger.textContent)).toEqual(expected)
 
     const logsTrigger = screen.getByRole('tab', { name: 'Logs' })
diff --git a/frontend/src/components/settings/SettingsDialog.tsx b/frontend/src/components/settings/SettingsDialog.tsx
index 0b8c2a296..a0dd04e7b 100644
--- a/frontend/src/components/settings/SettingsDialog.tsx
+++ b/frontend/src/components/settings/SettingsDialog.tsx
@@ -1,6 +1,7 @@
 import { useState, useEffect, useCallback } from 'react'
 import { GeneralSettings } from '@/components/settings/GeneralSettings'
 import { GitSettings } from '@/components/settings/GitSettings'
+import { OpenCodeServersSettings } from '@/components/settings/OpenCodeServersSettings'
 import { KeyboardShortcuts } from '@/components/settings/KeyboardShortcuts'
 import { OpenCodeConfigManager } from '@/components/settings/OpenCodeConfigManager'
 import { LogsViewer } from '@/components/settings/LogsViewer'
@@ -17,7 +18,7 @@ import { VersionSelectDialog } from '@/components/settings/VersionSelectDialog'
 import { Dialog, DialogContent, DialogTitle } from '@/components/ui/dialog'
 import { RowActionsMenuContext } from '@/components/ui/settings-list'
 import { Tabs, TabsContent, TabsList, TabsTrigger } from '@/components/ui/tabs'
-import { Settings2, Keyboard, Code, ChevronLeft, Key, GitBranch, User, Volume2, Bell, X, ScrollText, type LucideIcon } from 'lucide-react'
+import { Settings2, Keyboard, Code, ChevronLeft, Key, GitBranch, Server, User, Volume2, Bell, X, ScrollText, type LucideIcon } from 'lucide-react'
 import { Button } from '@/components/ui/button'
 import { useSettingsDialog, isSettingsContentTab, type SettingsContentTab } from '@/hooks/useSettingsDialog'
 import { DESKTOP_MEDIA_QUERY, useMediaQuery } from '@/hooks/useMediaQuery'
@@ -114,6 +115,7 @@ export function SettingsDialog() {
     { id: 'voice', icon: Volume2, label: 'Voice', description: 'Text-to-speech and speech-to-text settings' },
     { id: 'git', icon: GitBranch, label: 'Git', description: 'Git identity and credentials for repositories' },
     { id: 'shortcuts', icon: Keyboard, label: 'Keyboard Shortcuts', description: 'Customize keyboard shortcuts' },
+    { id: 'servers', icon: Server, label: 'Servers', description: 'Link remote OpenCode servers' },
     { id: 'opencode', icon: Code, label: 'OpenCode Config', description: 'Manage OpenCode configurations, commands, and agents' },
     { id: 'logs', icon: ScrollText, label: 'Logs', description: 'Live manager and OpenCode server logs' },
     { id: 'providers', icon: Key, label: 'Providers', description: 'Manage AI provider API keys' },
@@ -185,6 +187,7 @@ export function SettingsDialog() {
               <TabsContent key="voice" value="voice" className="mt-0 px-0 max-w-7xl"><VoiceSettings /></TabsContent>
               <TabsContent key="git" value="git" className="mt-0 px-0 max-w-7xl"><GitSettings /></TabsContent>
               <TabsContent key="shortcuts" value="shortcuts" className="mt-0 px-0 max-w-7xl"><KeyboardShortcuts /></TabsContent>
+              <TabsContent key="servers" value="servers" className="mt-0 px-0 max-w-7xl"><OpenCodeServersSettings /></TabsContent>
               <TabsContent key="opencode" value="opencode" className="mt-0 px-0">
                 <OpenCodeSettings onOpenVersionDialog={() => setIsVersionDialogOpen(true)} />
               </TabsContent>
@@ -251,6 +254,7 @@ export function SettingsDialog() {
              {mobileView === 'voice' && <div key="voice"><VoiceSettings /></div>}
              {mobileView === 'git' && <div key="git"><GitSettings /></div>}
               {mobileView === 'shortcuts' && <div key="shortcuts"><KeyboardShortcuts /></div>}
+              {mobileView === 'servers' && <div key="servers"><OpenCodeServersSettings /></div>}
                 {mobileView === 'opencode' && (
                    <OpenCodeSettings key="opencode" onOpenVersionDialog={() => setIsVersionDialogOpen(true)} />
                 )}
diff --git a/frontend/src/contexts/EventContext.test.tsx b/frontend/src/contexts/EventContext.test.tsx
index 28ba86d16..98e8190e5 100644
--- a/frontend/src/contexts/EventContext.test.tsx
+++ b/frontend/src/contexts/EventContext.test.tsx
@@ -9,7 +9,7 @@ import { FetchError } from '@opencode-manager/shared'
 import { showToast } from '@/lib/toast'
 import { useSessionStatus, hasBackgroundActivity } from '@/stores/sessionStatusStore'
 import { changeWalkthroughQueryKey } from '@/hooks/useChangeWalkthrough'
-import { EventProvider, useEventContext, useForms, usePermissions, useSSEHealth } from './EventContext'
+import { EventProvider, selectActiveSessionDirectoriesKey, useEventContext, useForms, usePermissions, useSSEHealth } from './EventContext'
 
 const mocks = vi.hoisted(() => ({
   listRepos: vi.fn(),
@@ -23,6 +23,8 @@ const mocks = vi.hoisted(() => ({
   cancelForm: vi.fn(),
   subscribeGlobalMonitor: vi.fn(),
   getHealth: vi.fn(),
+  listProjects: vi.fn(),
+  servers: [] as Array<{ id: string; enabled: boolean }>,
 }))
 
 vi.mock('@/api/repos', () => ({
@@ -33,6 +35,7 @@ vi.mock('@/api/opencode', () => ({
   listActiveSessions: mocks.listActiveSessions,
   listPendingPermissions: mocks.listPendingPermissions,
   listPendingForms: mocks.listPendingForms,
+  listProjects: mocks.listProjects,
   listShells: mocks.listShells,
   getSession: mocks.getSession,
   replyPermission: mocks.replyPermission,
@@ -40,6 +43,14 @@ vi.mock('@/api/opencode', () => ({
   cancelForm: mocks.cancelForm,
 }))
 
+vi.mock('@/hooks/useAuth', () => ({
+  useAuth: () => ({ isAuthenticated: true }),
+}))
+
+vi.mock('@/hooks/useOpenCodeServers', () => ({
+  useOpenCodeServers: () => ({ servers: mocks.servers }),
+}))
+
 vi.mock('@/lib/opencode-event-stream', () => ({
   openCodeEventStream: {
     subscribeGlobalMonitor: mocks.subscribeGlobalMonitor,
@@ -231,6 +242,8 @@ describe('EventProvider permissions and forms', () => {
     vi.clearAllMocks()
     window.history.pushState({}, '', '/')
     mocks.listRepos.mockResolvedValue([])
+    mocks.listProjects.mockResolvedValue([])
+    mocks.servers = []
     mocks.listPendingPermissions.mockResolvedValue([])
     mocks.listPendingForms.mockResolvedValue([])
     mocks.listActiveSessions.mockResolvedValue({})
@@ -240,7 +253,7 @@ describe('EventProvider permissions and forms', () => {
     mocks.replyForm.mockResolvedValue(undefined)
     mocks.cancelForm.mockResolvedValue(undefined)
     mocks.getHealth.mockReturnValue({ isConnected: false, isHealthy: false, lastEventAt: null, isStalled: false })
-    useSessionStatus.setState({ statuses: new Map(), statusCache: new Map(), statusRevisions: new Map(), knownSessions: new Set(), outcomes: new Map(), parents: new Map(), directories: new Map(), runningShells: new Map(), shellRevisions: new Map(), shellRevision: 0, revision: 0 })
+    useSessionStatus.setState({ statuses: new Map(), statusCache: new Map(), statusRevisions: new Map(), knownSessions: new Set(), outcomes: new Map(), parents: new Map(), directories: new Map(), sessionServers: new Map(), runningShells: new Map(), shellRevisions: new Map(), shellRevision: 0, revision: 0 })
     mocks.subscribeGlobalMonitor.mockReturnValue({
       dispose: vi.fn(),
       updateDirectories: vi.fn(),
@@ -324,7 +337,7 @@ describe('EventProvider permissions and forms', () => {
 
     await waitFor(() => {
       expect(mocks.replyPermission).toHaveBeenCalledTimes(1)
-      expect(mocks.replyPermission).toHaveBeenCalledWith('session-1', 'permission-1', 'reject', undefined)
+      expect(mocks.replyPermission).toHaveBeenCalledWith('session-1', 'permission-1', 'reject', undefined, 'local')
       expect(screen.getByTestId('permission-count')).toHaveTextContent('1')
       expect(screen.getByTestId('permission-current')).toHaveTextContent('permission-2')
     })
@@ -424,7 +437,7 @@ describe('EventProvider permissions and forms', () => {
     await userEvent.click(screen.getByRole('button', { name: 'Reject Permission With Reason' }))
 
     await waitFor(() =>
-      expect(mocks.replyPermission).toHaveBeenCalledWith('session-1', 'permission-1', 'reject', 'not allowed'),
+      expect(mocks.replyPermission).toHaveBeenCalledWith('session-1', 'permission-1', 'reject', 'not allowed', 'local'),
     )
   })
 
@@ -517,8 +530,8 @@ describe('EventProvider permissions and forms', () => {
     render(<Harness />, { wrapper: createWrapper() })
 
     await waitFor(() => {
-      expect(mocks.listPendingPermissions).toHaveBeenCalledWith('/repo')
-      expect(mocks.listPendingForms).toHaveBeenCalledWith('/repo')
+      expect(mocks.listPendingPermissions).toHaveBeenCalledWith('/repo', 'local')
+      expect(mocks.listPendingForms).toHaveBeenCalledWith('/repo', 'local')
     })
     await act(async () => {
       await Promise.resolve()
@@ -591,8 +604,8 @@ describe('EventProvider permissions and forms', () => {
     render(<Harness />, { wrapper: createWrapper() })
 
     await waitFor(() => {
-      expect(mocks.listPendingPermissions).toHaveBeenCalledWith('/repo')
-      expect(mocks.listPendingForms).toHaveBeenCalledWith('/repo')
+      expect(mocks.listPendingPermissions).toHaveBeenCalledWith('/repo', 'local')
+      expect(mocks.listPendingForms).toHaveBeenCalledWith('/repo', 'local')
     })
     await act(async () => {
       await Promise.resolve()
@@ -615,7 +628,7 @@ describe('EventProvider permissions and forms', () => {
     })
 
     await waitFor(() => {
-      expect(mocks.listPendingPermissions).toHaveBeenCalledWith('/worktrees/wt-1')
+      expect(mocks.listPendingPermissions).toHaveBeenCalledWith('/worktrees/wt-1', 'local')
       expect(screen.getByTestId('permission-count')).toHaveTextContent('0')
     })
   })
@@ -644,7 +657,7 @@ describe('EventProvider permissions and forms', () => {
 
     render(<Harness />, { wrapper: createWrapper() })
 
-    await waitFor(() => expect(mocks.listPendingPermissions).toHaveBeenCalledWith('/assistant'))
+    await waitFor(() => expect(mocks.listPendingPermissions).toHaveBeenCalledWith('/assistant', 'local'))
 
     const lastSubscribeCall = mocks.subscribeGlobalMonitor.mock.calls[mocks.subscribeGlobalMonitor.mock.calls.length - 1]
     const onEvent = lastSubscribeCall[0].onEvent as (data: unknown) => void
@@ -670,7 +683,7 @@ describe('EventProvider permissions and forms', () => {
 
     render(<Harness />, { wrapper: createWrapper() })
 
-    await waitFor(() => expect(mocks.listPendingPermissions).toHaveBeenCalledWith('/repo'))
+    await waitFor(() => expect(mocks.listPendingPermissions).toHaveBeenCalledWith('/repo', 'local'))
 
     const lastSubscribeCall = mocks.subscribeGlobalMonitor.mock.calls[mocks.subscribeGlobalMonitor.mock.calls.length - 1]
     const onEvent = lastSubscribeCall[0].onEvent as (data: unknown) => void
@@ -691,6 +704,49 @@ describe('EventProvider permissions and forms', () => {
     expect(screen.getByTestId('search').textContent).toBe('')
   })
 
+  it('navigates a linked-server permission without a Manager repo for its directory', async () => {
+    render(<Harness />, { wrapper: createWrapper() })
+
+    const lastSubscribeCall = mocks.subscribeGlobalMonitor.mock.calls[mocks.subscribeGlobalMonitor.mock.calls.length - 1]
+    const onEvent = lastSubscribeCall[0].onEvent as (data: unknown) => void
+
+    act(() => {
+      onEvent({ type: 'permission.asked', data: pendingPermission, directory: '/srv/app', serverId: 'srv_kitchen' })
+    })
+
+    await waitFor(() => {
+      expect(screen.getByTestId('permission-current')).toHaveTextContent('permission-1')
+    })
+
+    await userEvent.click(screen.getByRole('button', { name: 'Navigate Permission' }))
+
+    await waitFor(() => {
+      expect(screen.getByTestId('path')).toHaveTextContent('/servers/srv_kitchen/sessions/session-1')
+    })
+    expect(screen.getByTestId('search').textContent).toBe('')
+  })
+
+  it('navigates a linked-server form to its server session route', async () => {
+    render(<Harness />, { wrapper: createWrapper() })
+
+    const lastSubscribeCall = mocks.subscribeGlobalMonitor.mock.calls[mocks.subscribeGlobalMonitor.mock.calls.length - 1]
+    const onEvent = lastSubscribeCall[0].onEvent as (data: unknown) => void
+
+    act(() => {
+      onEvent({ type: 'form.created', data: { form: pendingForm }, directory: '/srv/app', serverId: 'srv_kitchen' })
+    })
+
+    await waitFor(() => {
+      expect(screen.getByTestId('current')).toHaveTextContent('form-1')
+    })
+
+    await userEvent.click(screen.getByRole('button', { name: 'Navigate' }))
+
+    await waitFor(() => {
+      expect(screen.getByTestId('path')).toHaveTextContent('/servers/srv_kitchen/sessions/session-1')
+    })
+  })
+
   it('does not navigate when already on the target session path', async () => {
     mocks.listRepos.mockResolvedValue([{ id: 123, fullPath: '/repo' }])
     window.history.pushState({}, '', '/repos/123/sessions/session-1')
@@ -699,7 +755,7 @@ describe('EventProvider permissions and forms', () => {
       wrapper: createWrapper(createTestQueryClient(), '/repos/123/sessions/session-1'),
     })
 
-    await waitFor(() => expect(mocks.listPendingPermissions).toHaveBeenCalledWith('/repo'))
+    await waitFor(() => expect(mocks.listPendingPermissions).toHaveBeenCalledWith('/repo', 'local'))
 
     const lastSubscribeCall = mocks.subscribeGlobalMonitor.mock.calls[mocks.subscribeGlobalMonitor.mock.calls.length - 1]
     const onEvent = lastSubscribeCall[0].onEvent as (data: unknown) => void
@@ -754,7 +810,7 @@ describe('EventProvider permissions and forms', () => {
     await userEvent.click(screen.getByRole('button', { name: 'Dismiss' }))
 
     await waitFor(() => {
-      expect(mocks.cancelForm).toHaveBeenCalledWith('session-1', 'form-1')
+      expect(mocks.cancelForm).toHaveBeenCalledWith('session-1', 'form-1', 'local')
       expect(screen.getByTestId('count')).toHaveTextContent('0')
       expect(screen.getByTestId('current')).toHaveTextContent('none')
     })
@@ -774,7 +830,7 @@ describe('EventProvider permissions and forms', () => {
     await userEvent.click(screen.getByRole('button', { name: 'Reply' }))
 
     await waitFor(() => {
-      expect(mocks.replyForm).toHaveBeenCalledWith('session-1', 'form-1', { q0: 'Yes' })
+      expect(mocks.replyForm).toHaveBeenCalledWith('session-1', 'form-1', { q0: 'Yes' }, 'local')
       expect(screen.getByTestId('count')).toHaveTextContent('0')
       expect(screen.getByTestId('current')).toHaveTextContent('none')
     })
@@ -1147,7 +1203,7 @@ describe('EventProvider permissions and forms', () => {
     render(<Harness />, { wrapper: createWrapper() })
 
     await waitFor(() => {
-      expect(mocks.listPendingForms).toHaveBeenCalledWith('/repo-b')
+      expect(mocks.listPendingForms).toHaveBeenCalledWith('/repo-b', 'local')
     })
     await act(async () => {
       await Promise.resolve()
@@ -1170,10 +1226,10 @@ describe('EventProvider permissions and forms', () => {
       onResync?.([])
     })
 
-    expect(mocks.listPendingPermissions).toHaveBeenCalledWith('/repo-a')
-    expect(mocks.listPendingPermissions).toHaveBeenCalledWith('/repo-b')
-    expect(mocks.listPendingForms).toHaveBeenCalledWith('/repo-a')
-    expect(mocks.listPendingForms).toHaveBeenCalledWith('/repo-b')
+    expect(mocks.listPendingPermissions).toHaveBeenCalledWith('/repo-a', 'local')
+    expect(mocks.listPendingPermissions).toHaveBeenCalledWith('/repo-b', 'local')
+    expect(mocks.listPendingForms).toHaveBeenCalledWith('/repo-a', 'local')
+    expect(mocks.listPendingForms).toHaveBeenCalledWith('/repo-b', 'local')
 
     await act(async () => {
       pending.forEach((resolve) => resolve())
@@ -1533,7 +1589,7 @@ describe('EventProvider permissions and forms', () => {
     })
 
     await waitFor(() => {
-      expect(mocks.getSession).toHaveBeenCalledWith('child-1')
+      expect(mocks.getSession).toHaveBeenCalledWith('child-1', 'local')
       expect(useSessionStatus.getState().parents.get('child-1')).toBe('parent-1')
     })
     expect(screen.getByTestId('permission-current')).toHaveTextContent('permission-child')
@@ -1561,7 +1617,7 @@ describe('EventProvider permissions and forms', () => {
     })
 
     await waitFor(() => {
-      expect(mocks.getSession).toHaveBeenCalledWith('child-1')
+      expect(mocks.getSession).toHaveBeenCalledWith('child-1', 'local')
       expect(useSessionStatus.getState().parents.get('child-1')).toBe('parent-1')
     })
     expect(screen.getByTestId('current')).toHaveTextContent('form-child')
@@ -2367,7 +2423,7 @@ describe('EventProvider permissions and forms', () => {
 
     render(<Harness />, { wrapper: createWrapper() })
 
-    await waitFor(() => expect(mocks.listPendingForms).toHaveBeenCalledWith('/repo'))
+    await waitFor(() => expect(mocks.listPendingForms).toHaveBeenCalledWith('/repo', 'local'))
 
     const lastSubscribeCall = mocks.subscribeGlobalMonitor.mock.calls[mocks.subscribeGlobalMonitor.mock.calls.length - 1]
     const handleStatusChange = lastSubscribeCall[0].onStatusChange as (connected: boolean) => void
@@ -2377,7 +2433,7 @@ describe('EventProvider permissions and forms', () => {
     })
 
     await waitFor(() => {
-      expect(mocks.listShells).toHaveBeenCalledWith('/repo')
+      expect(mocks.listShells).toHaveBeenCalledWith('/repo', 'local')
       expect(useSessionStatus.getState().runningShells.get('shell-1')).toEqual({
         sessionID: 'session-1',
         directory: '/repo',
@@ -2403,7 +2459,7 @@ describe('EventProvider permissions and forms', () => {
       onDirectoriesSubscribed(['/repo'])
     })
 
-    await waitFor(() => expect(mocks.listShells).toHaveBeenCalledWith('/repo'))
+    await waitFor(() => expect(mocks.listShells).toHaveBeenCalledWith('/repo', 'local'))
 
     act(() => {
       onEvent({ type: 'shell.exited', data: { id: 'shell-1', status: 'exited' }, directory: '/repo' })
@@ -2434,7 +2490,7 @@ describe('EventProvider permissions and forms', () => {
       onDirectoriesSubscribed(['/repo'])
     })
 
-    await waitFor(() => expect(mocks.listShells).toHaveBeenCalledWith('/repo'))
+    await waitFor(() => expect(mocks.listShells).toHaveBeenCalledWith('/repo', 'local'))
 
     act(() => {
       onEvent({
@@ -2512,7 +2568,7 @@ describe('EventProvider permissions and forms', () => {
       expect(useSessionStatus.getState().parents.get('parent-1')).toBe('grandparent-1')
       expect(useSessionStatus.getState().parents.get('grandparent-1')).toBeNull()
     })
-    expect(mocks.getSession).toHaveBeenCalledWith('parent-1')
+    expect(mocks.getSession).toHaveBeenCalledWith('parent-1', 'local')
   })
 
   it('syncs running shells for a directory whose repo arrives after connect', async () => {
@@ -2543,7 +2599,7 @@ describe('EventProvider permissions and forms', () => {
       await reposDeferred.promise
     })
 
-    await waitFor(() => expect(mocks.listShells).toHaveBeenCalledWith('/repo'))
+    await waitFor(() => expect(mocks.listShells).toHaveBeenCalledWith('/repo', 'local'))
   })
 
   it('reconciles newly subscribed directories reported by the stream', async () => {
@@ -2567,9 +2623,9 @@ describe('EventProvider permissions and forms', () => {
     })
 
     await waitFor(() => {
-      expect(mocks.listShells).toHaveBeenCalledWith('/session-dir')
-      expect(mocks.listPendingPermissions).toHaveBeenCalledWith('/session-dir')
-      expect(mocks.listPendingForms).toHaveBeenCalledWith('/session-dir')
+      expect(mocks.listShells).toHaveBeenCalledWith('/session-dir', 'local')
+      expect(mocks.listPendingPermissions).toHaveBeenCalledWith('/session-dir', 'local')
+      expect(mocks.listPendingForms).toHaveBeenCalledWith('/session-dir', 'local')
     })
     expect(useSessionStatus.getState().runningShells.has('shell-stale')).toBe(false)
     expect(screen.getByTestId('permission-count').textContent).toBe('1')
@@ -2597,9 +2653,9 @@ describe('EventProvider permissions and forms', () => {
     })
 
     await waitFor(() => {
-      expect(mocks.listShells).toHaveBeenCalledWith('/unregistered-dir')
-      expect(mocks.listPendingPermissions).toHaveBeenCalledWith('/unregistered-dir')
-      expect(mocks.listPendingForms).toHaveBeenCalledWith('/unregistered-dir')
+      expect(mocks.listShells).toHaveBeenCalledWith('/unregistered-dir', 'local')
+      expect(mocks.listPendingPermissions).toHaveBeenCalledWith('/unregistered-dir', 'local')
+      expect(mocks.listPendingForms).toHaveBeenCalledWith('/unregistered-dir', 'local')
     })
     expect(useSessionStatus.getState().runningShells.has('shell-stale')).toBe(false)
     expect(screen.getByTestId('permission-count').textContent).toBe('1')
@@ -2644,4 +2700,227 @@ describe('EventProvider permissions and forms', () => {
       expect(lastDirectories).not.toContain('/repo/.worktrees/feature')
     })
   })
+
+  it('selects the server-keyed directory of an active remote session', () => {
+    const key = selectActiveSessionDirectoriesKey({
+      statuses: new Map([['remote-session', { type: 'busy' as const }]]),
+      directories: new Map([['remote-session', 'srv_remote|/remote/repo']]),
+      runningShells: new Map([
+        ['shell-1', { sessionID: 'remote-session', directory: 'srv_remote|/remote/repo' }],
+      ]),
+    })
+
+    expect(key).toBe('srv_remote|/remote/repo')
+  })
+
+  it('keys a remote session directory and routes its lookups to the remote server', async () => {
+    mocks.listRepos.mockResolvedValue([{ id: 123, fullPath: '/repo' }])
+    const updateDirectories = vi.fn()
+    mocks.subscribeGlobalMonitor.mockReturnValue({
+      dispose: vi.fn(),
+      updateDirectories,
+      reconnect: vi.fn(),
+      reportVisibility: vi.fn(),
+    })
+
+    render(<Harness />, { wrapper: createWrapper() })
+
+    await waitFor(() => expect(mocks.subscribeGlobalMonitor).toHaveBeenCalled())
+
+    const lastSubscribeCall = mocks.subscribeGlobalMonitor.mock.calls[mocks.subscribeGlobalMonitor.mock.calls.length - 1]
+    const onEvent = lastSubscribeCall[0].onEvent as (data: unknown) => void
+
+    act(() => {
+      onEvent({
+        type: 'session.status',
+        serverId: 'srv_remote',
+        directory: '/remote/repo',
+        data: { sessionID: 'remote-session', status: { type: 'busy' } },
+      })
+    })
+
+    expect(useSessionStatus.getState().directories.get('remote-session')).toBe('srv_remote|/remote/repo')
+    expect(useSessionStatus.getState().getStatus('remote-session')).toEqual({ type: 'busy' })
+
+    await waitFor(() => {
+      expect(updateDirectories).toHaveBeenCalledWith(expect.arrayContaining(['srv_remote|/remote/repo']))
+    })
+
+    const onDirectoriesSubscribed = lastSubscribeCall[0].onDirectoriesSubscribed as (directories: string[]) => void
+    await act(async () => {
+      onDirectoriesSubscribed(['srv_remote|/remote/repo'])
+    })
+
+    await waitFor(() => {
+      expect(mocks.listPendingPermissions).toHaveBeenCalledWith('/remote/repo', 'srv_remote')
+      expect(mocks.listPendingForms).toHaveBeenCalledWith('/remote/repo', 'srv_remote')
+      expect(mocks.listShells).toHaveBeenCalledWith('/remote/repo', 'srv_remote')
+    })
+  })
+
+  it('keeps a remote session busy across a local active-session snapshot', async () => {
+    mocks.listRepos.mockResolvedValue([{ id: 123, fullPath: '/repo' }])
+    mocks.listActiveSessions.mockResolvedValue({})
+
+    render(<Harness />, { wrapper: createWrapper() })
+
+    await waitFor(() => expect(mocks.subscribeGlobalMonitor).toHaveBeenCalled())
+
+    const lastSubscribeCall = mocks.subscribeGlobalMonitor.mock.calls[mocks.subscribeGlobalMonitor.mock.calls.length - 1]
+    const onEvent = lastSubscribeCall[0].onEvent as (data: unknown) => void
+    const handleStatusChange = lastSubscribeCall[0].onStatusChange as (connected: boolean) => void
+
+    act(() => {
+      onEvent({
+        type: 'session.status',
+        serverId: 'srv_remote',
+        data: { sessionID: 'remote-session', status: { type: 'busy' } },
+      })
+    })
+
+    expect(useSessionStatus.getState().directories.has('remote-session')).toBe(false)
+
+    vi.useFakeTimers()
+    try {
+      act(() => {
+        handleStatusChange(true)
+      })
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(5000)
+      })
+
+      expect(mocks.listActiveSessions).toHaveBeenCalledTimes(2)
+      expect(useSessionStatus.getState().getStatus('remote-session')).toEqual({ type: 'busy' })
+      expect(useSessionStatus.getState().knownSessions.has('remote-session')).toBe(true)
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  it('scopes a remote resync to that server and skips the local snapshot', async () => {
+    const queryClient = createTestQueryClient()
+    const invalidateQueries = vi.spyOn(queryClient, 'invalidateQueries')
+
+    render(<Harness />, { wrapper: createWrapper(queryClient) })
+
+    await waitFor(() => expect(mocks.subscribeGlobalMonitor).toHaveBeenCalled())
+
+    mocks.listActiveSessions.mockClear()
+    mocks.listPendingPermissions.mockClear()
+    mocks.listPendingForms.mockClear()
+    mocks.listShells.mockClear()
+    invalidateQueries.mockClear()
+
+    const lastSubscribeCall = mocks.subscribeGlobalMonitor.mock.calls[mocks.subscribeGlobalMonitor.mock.calls.length - 1]
+    const onResync = lastSubscribeCall[0].onResync as
+      | ((directories: string[], serverId?: string) => void)
+      | undefined
+
+    await act(async () => {
+      onResync?.(['/repo', 'srv_remote|/remote/repo'], 'srv_remote')
+    })
+
+    await waitFor(() => {
+      expect(mocks.listPendingPermissions).toHaveBeenCalledWith('/remote/repo', 'srv_remote')
+      expect(mocks.listPendingForms).toHaveBeenCalledWith('/remote/repo', 'srv_remote')
+      expect(mocks.listShells).toHaveBeenCalledWith('/remote/repo', 'srv_remote')
+    })
+    expect(mocks.listActiveSessions).not.toHaveBeenCalledWith()
+    expect(mocks.listActiveSessions).toHaveBeenCalledWith('srv_remote')
+    expect(mocks.listPendingPermissions).not.toHaveBeenCalledWith('/repo', 'local')
+    expect(mocks.listShells).not.toHaveBeenCalledWith('/repo', 'local')
+
+    await waitFor(() => {
+      expect(invalidateQueries).toHaveBeenCalledWith({ queryKey: ['opencode', 'commands', 'srv_remote'] })
+      expect(invalidateQueries).toHaveBeenCalledWith({ queryKey: ['opencode', 'agents', 'srv_remote'] })
+    })
+    expect(invalidateQueries).not.toHaveBeenCalledWith({ queryKey: ['opencode', 'commands'] })
+  })
+
+  it('clears a stale remote busy status on a remote resync', async () => {
+    mocks.listRepos.mockResolvedValue([{ id: 123, fullPath: '/repo' }])
+    mocks.listActiveSessions.mockResolvedValue({})
+
+    render(<Harness />, { wrapper: createWrapper() })
+
+    await waitFor(() => expect(mocks.subscribeGlobalMonitor).toHaveBeenCalled())
+
+    act(() => {
+      useSessionStatus.getState().setSessionServer('remote-session', 'srv_remote')
+      useSessionStatus.getState().setStatus('remote-session', { type: 'busy' })
+    })
+
+    const lastSubscribeCall = mocks.subscribeGlobalMonitor.mock.calls[mocks.subscribeGlobalMonitor.mock.calls.length - 1]
+    const onResync = lastSubscribeCall[0].onResync as
+      | ((directories: string[], serverId?: string) => void)
+      | undefined
+
+    await act(async () => {
+      onResync?.(['srv_remote|/remote/repo'], 'srv_remote')
+    })
+
+    await waitFor(() => {
+      expect(mocks.listActiveSessions).toHaveBeenCalledWith('srv_remote')
+      expect(useSessionStatus.getState().getStatus('remote-session')).toEqual({ type: 'idle' })
+    })
+  })
+
+  it('reconciles every enabled remote server when the browser stream reconnects', async () => {
+    mocks.servers = [
+      { id: 'srv_remote', enabled: true },
+      { id: 'srv_disabled', enabled: false },
+    ]
+    mocks.listRepos.mockResolvedValue([{ id: 123, fullPath: '/repo' }])
+    mocks.listActiveSessions.mockResolvedValue({})
+
+    render(<Harness />, { wrapper: createWrapper() })
+
+    await waitFor(() => expect(mocks.subscribeGlobalMonitor).toHaveBeenCalled())
+
+    act(() => {
+      useSessionStatus.getState().setSessionServer('remote-session', 'srv_remote')
+      useSessionStatus.getState().setStatus('remote-session', { type: 'busy' })
+    })
+
+    const lastSubscribeCall = mocks.subscribeGlobalMonitor.mock.calls[mocks.subscribeGlobalMonitor.mock.calls.length - 1]
+    const handleStatusChange = lastSubscribeCall[0].onStatusChange as (connected: boolean) => void
+
+    act(() => {
+      handleStatusChange(true)
+    })
+
+    await waitFor(() => {
+      expect(mocks.listActiveSessions).toHaveBeenCalledWith('srv_remote')
+      expect(useSessionStatus.getState().getStatus('remote-session')).toEqual({ type: 'idle' })
+    })
+    expect(mocks.listActiveSessions).not.toHaveBeenCalledWith('srv_disabled')
+  })
+
+  it('subscribes the project directories of enabled remote servers', async () => {
+    mocks.servers = [{ id: 'srv_remote', enabled: true }]
+    mocks.listProjects.mockResolvedValue([{ id: 'proj-1', canonical: '/remote/repo' }])
+    const updateDirectories = vi.fn()
+    mocks.subscribeGlobalMonitor.mockReturnValue({
+      dispose: vi.fn(),
+      updateDirectories,
+      reconnect: vi.fn(),
+      reportVisibility: vi.fn(),
+    })
+
+    render(<Harness />, { wrapper: createWrapper() })
+
+    await waitFor(() => expect(mocks.listProjects).toHaveBeenCalledWith('srv_remote'))
+    await waitFor(() => {
+      expect(updateDirectories).toHaveBeenCalledWith(expect.arrayContaining(['srv_remote|/remote/repo']))
+    })
+  })
+
+  it('does not fetch projects for disabled remote servers', async () => {
+    mocks.servers = [{ id: 'srv_disabled', enabled: false }]
+
+    render(<Harness />, { wrapper: createWrapper() })
+
+    await waitFor(() => expect(mocks.subscribeGlobalMonitor).toHaveBeenCalled())
+    expect(mocks.listProjects).not.toHaveBeenCalled()
+  })
 })
diff --git a/frontend/src/contexts/EventContext.tsx b/frontend/src/contexts/EventContext.tsx
index deaf77820..b309d15c5 100644
--- a/frontend/src/contexts/EventContext.tsx
+++ b/frontend/src/contexts/EventContext.tsx
@@ -1,25 +1,31 @@
 /* eslint-disable react-refresh/only-export-components */
 import { createContext, useContext, useEffect, useState, useCallback, useMemo, useRef } from 'react'
 import { useLocation, useNavigate } from 'react-router-dom'
-import { useQueryClient, useQuery } from '@tanstack/react-query'
+import { useQueryClient, useQuery, useQueries } from '@tanstack/react-query'
 import {
   cancelForm,
   getSession,
   listActiveSessions,
   listPendingForms,
   listPendingPermissions,
+  listProjects,
   listShells,
   replyForm,
   replyPermission,
 } from '@/api/opencode'
 import { listRepos } from '@/api/repos'
 import { FetchError } from '@opencode-manager/shared'
+import { buildServerDirectoryKey, LOCAL_OPENCODE_SERVER_ID, parseServerDirectoryKey } from '@opencode-manager/shared/schemas'
+import { isLocalOpenCodeServer } from '@/contexts/OpenCodeServerContext'
+import { useAuth } from '@/hooks/useAuth'
+import { useOpenCodeServers } from '@/hooks/useOpenCodeServers'
 import type { FormAnswer, FormInfo, PermissionRequest, V2Event } from '@opencode-manager/shared/opencode'
 import type { PermissionResponse, SSHHostKeyRequest, Repo } from '@/api/types'
 import { showToast } from '@/lib/toast'
 import { openCodeEventStream, type EventStreamHealthState } from '@/lib/opencode-event-stream'
 import { addToSessionKeyedState, removeFromSessionKeyedState } from '@/lib/sessionKeyedState'
-import { getSessionPath, parseRepoRoute } from '@/lib/navigation'
+import { getServerSessionPath, getSessionPath, parseRepoRoute, parseServerSessionRoute } from '@/lib/navigation'
+import { serverScopedKey } from '@/lib/serverScope'
 import { repoMatchesDirectory } from '@/components/navigation/sidebar-session-tree'
 import { changeWalkthroughQueryKey } from '@/hooks/useChangeWalkthrough'
 import { busyStatusesFromActiveSessions, useSessionStatus } from '@/stores/sessionStatusStore'
@@ -40,10 +46,15 @@ const LOCATION_CATALOG_QUERY_KEYS = [
   ['opencode', 'providers'],
 ] as const
 
-type PermissionsBySession = Record<string, PermissionRequest[]>
-type FormsBySession = Record<string, FormInfo[]>
+type ServerScoped<T> = T & { serverId: string }
+type PendingPermission = ServerScoped<PermissionRequest>
+type PendingForm = ServerScoped<FormInfo>
+type PermissionsBySession = Record<string, PendingPermission[]>
+type FormsBySession = Record<string, PendingForm[]>
 type SSEHealthState = Pick<EventStreamHealthState, 'isConnected' | 'isHealthy' | 'isStalled'>
-type StreamEvent = (V2Event & { directory?: string }) | { type: 'ssh.host-key-request'; properties: SSHHostKeyRequest }
+type StreamEvent =
+  | (V2Event & { directory?: string; serverId?: string })
+  | { type: 'ssh.host-key-request'; properties: SSHHostKeyRequest }
 
 type SessionScopedItem = { id: string; sessionID: string }
 
@@ -122,9 +133,10 @@ function usePinnedViewedItem<T extends SessionScopedItem>(
   return selected
 }
 
-function reconcileBySessionForDirectory<T extends SessionScopedItem>(
+function reconcileBySessionForDirectory<T extends SessionScopedItem & { serverId: string }>(
   prev: Record<string, T[]>,
-  directory: string,
+  directoryKey: string,
+  serverId: string,
   items: T[],
   sessionDirectories: ReadonlyMap<string, string>,
 ): Record<string, T[]> {
@@ -133,7 +145,8 @@ function reconcileBySessionForDirectory<T extends SessionScopedItem>(
 
   for (const sessionID of Object.keys(prev)) {
     if (grouped[sessionID]) continue
-    if (sessionDirectories.get(sessionID) === directory) {
+    if (sessionDirectories.get(sessionID) !== directoryKey) continue
+    if ((prev[sessionID]?.[0]?.serverId ?? LOCAL_OPENCODE_SERVER_ID) === serverId) {
       delete next[sessionID]
     }
   }
@@ -153,7 +166,7 @@ interface SSHHostKeyState {
 interface EventContextValue {
   sshHostKey: SSHHostKeyState
   permissions: {
-    current: PermissionRequest | null
+    current: PendingPermission | null
     pendingCount: number
     /**
      * Ids of sessions with at least one pending permission request, stable while the queue is unchanged.
@@ -189,10 +202,10 @@ interface EventContextValue {
     showDialog: boolean
     setShowDialog: (show: boolean) => void
     navigateToCurrent: () => void
-    syncForSession: (directory: string, sessionID: string) => Promise<void>
+    syncForSession: (directory: string, sessionID: string, serverId?: string) => Promise<void>
   }
   forms: {
-    current: FormInfo | null
+    current: PendingForm | null
     pendingCount: number
     /**
      * Ids of sessions with at least one pending form, stable while the queue is unchanged.
@@ -212,7 +225,7 @@ interface EventContextValue {
     getForSession: (sessionID: string) => FormInfo | null
     hasForSession: (sessionID: string) => boolean
     navigateToCurrent: () => void
-    syncForSession: (directory: string, sessionID: string) => Promise<void>
+    syncForSession: (directory: string, sessionID: string, serverId?: string) => Promise<void>
   }
   sseHealth: SSEHealthState
   getRepoIdForSession: (sessionID: string) => number | null
@@ -297,6 +310,7 @@ export function EventProvider({ children }: { children: React.ReactNode }) {
   const prevPermissionCountRef = useRef(0)
   const initialFetchDoneRef = useRef(false)
   const statusSyncVersionRef = useRef(0)
+  const remoteStatusSyncVersionsRef = useRef(new Map<string, number>())
   const statusPollIntervalRef = useRef<ReturnType<typeof setInterval> | null>(null)
   const subscriptionRef = useRef<ReturnType<typeof openCodeEventStream.subscribeGlobalMonitor> | null>(null)
   const reposRef = useRef<typeof repos>(null)
@@ -307,6 +321,32 @@ export function EventProvider({ children }: { children: React.ReactNode }) {
     queryFn: listRepos,
   })
 
+  const { isAuthenticated } = useAuth()
+  const { servers } = useOpenCodeServers({ enabled: isAuthenticated })
+  const enabledRemoteServers = useMemo(() => servers.filter((server) => server.enabled), [servers])
+  const enabledRemoteServersRef = useRef(enabledRemoteServers)
+  useEffect(() => {
+    enabledRemoteServersRef.current = enabledRemoteServers
+  }, [enabledRemoteServers])
+  const remoteProjectQueries = useQueries({
+    queries: enabledRemoteServers.map((server) => ({
+      queryKey: serverScopedKey(['opencode', 'projects'], server.id),
+      queryFn: () => listProjects(server.id),
+      enabled: isAuthenticated,
+      retry: false,
+    })),
+  })
+  const remoteProjectDirectoriesKey = useMemo(() => {
+    if (!isAuthenticated) return ''
+    const keys = new Set<string>()
+    enabledRemoteServers.forEach((server, index) => {
+      for (const project of remoteProjectQueries[index]?.data ?? []) {
+        if (project.canonical) keys.add(buildServerDirectoryKey(server.id, project.canonical))
+      }
+    })
+    return [...keys].sort().join('\n')
+  }, [isAuthenticated, enabledRemoteServers, remoteProjectQueries])
+
   const allPermissions = useMemo(() => Object.values(permissionsBySession).flat(), [permissionsBySession])
   const allForms = useMemo(() => Object.values(formsBySession).flat(), [formsBySession])
 
@@ -314,7 +354,7 @@ export function EventProvider({ children }: { children: React.ReactNode }) {
   const pendingFormSessionIDs = usePendingSessionIDs(formsBySession)
 
   const viewedSessionId = useMemo(
-    () => parseRepoRoute(location.pathname).sessionId,
+    () => parseServerSessionRoute(location.pathname)?.sessionId ?? parseRepoRoute(location.pathname).sessionId,
     [location.pathname],
   )
 
@@ -322,9 +362,15 @@ export function EventProvider({ children }: { children: React.ReactNode }) {
 
   const currentForm = usePinnedViewedItem(allForms, viewedSessionId, sessionParents)
 
-  const rememberSessionDirectory = useCallback((sessionID: string, directory?: string) => {
+  const rememberSessionDirectory = useCallback((
+    sessionID: string,
+    directory?: string,
+    serverId: string = LOCAL_OPENCODE_SERVER_ID,
+  ) => {
     if (!directory) return
-    useSessionStatus.getState().setSessionDirectory(sessionID, directory)
+    const state = useSessionStatus.getState()
+    state.setSessionServer(sessionID, serverId)
+    state.setSessionDirectory(sessionID, buildServerDirectoryKey(serverId, directory))
   }, [])
 
   const findCachedSessionDirectory = useCallback((sessionID: string): string | null => {
@@ -373,19 +419,27 @@ export function EventProvider({ children }: { children: React.ReactNode }) {
     return directory ?? null
   }, [queryClient])
 
-  const findSessionDirectory = useCallback((sessionID: string): string | null => {
+  const findSessionDirectoryKey = useCallback((sessionID: string): string | null => {
     const remembered = useSessionStatus.getState().directories.get(sessionID)
     if (remembered) return remembered
     return findCachedSessionDirectory(sessionID)
   }, [findCachedSessionDirectory])
 
+  const findSessionDirectory = useCallback((sessionID: string): string | null => {
+    const key = findSessionDirectoryKey(sessionID)
+    return key ? parseServerDirectoryKey(key).directory : null
+  }, [findSessionDirectoryKey])
+
   const getRepoIdForSession = useCallback((sessionID: string): number | null => {
     if (!repos) return null
-    const directory = findSessionDirectory(sessionID)
-    if (!directory) return null
+    if (useSessionStatus.getState().sessionServers.has(sessionID)) return null
+    const key = findSessionDirectoryKey(sessionID)
+    if (!key) return null
+    const { serverId, directory } = parseServerDirectoryKey(key)
+    if (!isLocalOpenCodeServer(serverId)) return null
     const repo = repos.find(r => repoMatchesDirectory(r, directory))
     return repo?.id ?? null
-  }, [repos, findSessionDirectory])
+  }, [repos, findSessionDirectoryKey])
 
   const currentPermissionDirectory = useMemo(
     () => (currentPermission ? findSessionDirectory(currentPermission.sessionID) : null),
@@ -396,39 +450,59 @@ export function EventProvider({ children }: { children: React.ReactNode }) {
     && currentPermission !== null
     && !isSessionWithinView(currentPermission.sessionID, viewedSessionId, sessionParents)
 
-  const addPermission = useCallback((permission: PermissionRequest) => {
-    addToSessionKeyedState(setPermissionsBySession, permission)
+  const addPermission = useCallback((permission: PermissionRequest, serverId: string) => {
+    addToSessionKeyedState(setPermissionsBySession, { ...permission, serverId })
   }, [])
 
   const removePermission = useCallback((permissionID: string, sessionID?: string) => {
     removeFromSessionKeyedState(setPermissionsBySession, permissionID, sessionID)
   }, [])
 
-  const addForm = useCallback((form: FormInfo) => {
-    addToSessionKeyedState(setFormsBySession, form)
+  const addForm = useCallback((form: FormInfo, serverId: string) => {
+    addToSessionKeyedState(setFormsBySession, { ...form, serverId })
   }, [])
 
   const removeForm = useCallback((formID: string, sessionID?: string) => {
     removeFromSessionKeyedState(setFormsBySession, formID, sessionID)
   }, [])
 
-  const reconcilePermissionsForDirectory = useCallback((directory: string, permissions: PermissionRequest[]) => {
+  const reconcilePermissionsForDirectory = useCallback((
+    directory: string,
+    permissions: PermissionRequest[],
+    serverId: string,
+  ) => {
     permissions.forEach(permission => {
-      rememberSessionDirectory(permission.sessionID, directory)
+      rememberSessionDirectory(permission.sessionID, directory, serverId)
     })
 
     setPermissionsBySession(prev =>
-      reconcileBySessionForDirectory(prev, directory, permissions, useSessionStatus.getState().directories),
+      reconcileBySessionForDirectory(
+        prev,
+        buildServerDirectoryKey(serverId, directory),
+        serverId,
+        permissions.map(permission => ({ ...permission, serverId })),
+        useSessionStatus.getState().directories,
+      ),
     )
   }, [rememberSessionDirectory])
 
-  const reconcileFormsForDirectory = useCallback((directory: string, forms: FormInfo[]) => {
+  const reconcileFormsForDirectory = useCallback((
+    directory: string,
+    forms: FormInfo[],
+    serverId: string,
+  ) => {
     forms.forEach(form => {
-      rememberSessionDirectory(form.sessionID, directory)
+      rememberSessionDirectory(form.sessionID, directory, serverId)
     })
 
     setFormsBySession(prev =>
-      reconcileBySessionForDirectory(prev, directory, forms, useSessionStatus.getState().directories),
+      reconcileBySessionForDirectory(
+        prev,
+        buildServerDirectoryKey(serverId, directory),
+        serverId,
+        forms.map(form => ({ ...form, serverId })),
+        useSessionStatus.getState().directories,
+      ),
     )
   }, [rememberSessionDirectory])
 
@@ -452,25 +526,34 @@ export function EventProvider({ children }: { children: React.ReactNode }) {
     response: PermissionResponse,
     message?: string,
   ) => {
+    const permission = allPermissions.find(candidate => candidate.id === permissionID)
     await settlePendingReply(
-      () => replyPermission(sessionID, permissionID, response, message),
+      () => replyPermission(sessionID, permissionID, response, message, permission?.serverId),
       'PermissionNotFoundError',
       'Permission request expired',
     )
     removePermission(permissionID, sessionID)
-  }, [removePermission])
+  }, [allPermissions, removePermission])
 
   const replyToForm = useCallback(async (formID: string, answer: FormAnswer) => {
     const form = Object.values(formsBySession).flat().find(f => f.id === formID)
     if (!form) throw new Error('Form not found')
-    await settlePendingReply(() => replyForm(form.sessionID, formID, answer), 'FormNotFoundError', 'Form expired')
+    await settlePendingReply(
+      () => replyForm(form.sessionID, formID, answer, form.serverId),
+      'FormNotFoundError',
+      'Form expired',
+    )
     removeForm(formID, form.sessionID)
   }, [formsBySession, removeForm])
 
   const cancelPendingForm = useCallback(async (formID: string) => {
     const form = Object.values(formsBySession).flat().find(f => f.id === formID)
     if (!form) throw new Error('Form not found')
-    await settlePendingReply(() => cancelForm(form.sessionID, formID), 'FormNotFoundError', 'Form expired')
+    await settlePendingReply(
+      () => cancelForm(form.sessionID, formID, form.serverId),
+      'FormNotFoundError',
+      'Form expired',
+    )
     removeForm(formID, form.sessionID)
   }, [formsBySession, removeForm])
 
@@ -499,10 +582,15 @@ export function EventProvider({ children }: { children: React.ReactNode }) {
     return (formsBySession[sessionID]?.length ?? 0) > 0
   }, [formsBySession])
 
-  const navigateToSession = useCallback((sessionID: string) => {
-    const repoId = getRepoIdForSession(sessionID)
-    if (repoId === null) return
-    const targetPath = getSessionPath(repoId, sessionID)
+  const navigateToSession = useCallback((sessionID: string, serverId: string) => {
+    let targetPath: string
+    if (isLocalOpenCodeServer(serverId)) {
+      const repoId = getRepoIdForSession(sessionID)
+      if (repoId === null) return
+      targetPath = getSessionPath(repoId, sessionID)
+    } else {
+      targetPath = getServerSessionPath(serverId, sessionID)
+    }
     if (`${window.location.pathname}${window.location.search}` !== targetPath) {
       navigate(targetPath)
     }
@@ -510,23 +598,24 @@ export function EventProvider({ children }: { children: React.ReactNode }) {
 
   const navigateToCurrentForm = useCallback(() => {
     if (!currentForm) return
-    navigateToSession(currentForm.sessionID)
+    navigateToSession(currentForm.sessionID, currentForm.serverId)
   }, [currentForm, navigateToSession])
 
   const navigateToCurrentPermission = useCallback(() => {
     if (!currentPermission) return
-    navigateToSession(currentPermission.sessionID)
+    navigateToSession(currentPermission.sessionID, currentPermission.serverId)
   }, [currentPermission, navigateToSession])
 
   const reconcilePendingActionsForDirectories = useCallback(async (directories: string[]) => {
-    await Promise.all(directories.map(async (directory) => {
+    await Promise.all(directories.map(async (key) => {
+      const { serverId, directory } = parseServerDirectoryKey(key)
       try {
         const [pendingPermissions, pendingForms] = await Promise.all([
-          listPendingPermissions(directory),
-          listPendingForms(directory),
+          listPendingPermissions(directory, serverId),
+          listPendingForms(directory, serverId),
         ])
-        reconcilePermissionsForDirectory(directory, pendingPermissions)
-        reconcileFormsForDirectory(directory, pendingForms)
+        reconcilePermissionsForDirectory(directory, pendingPermissions, serverId)
+        reconcileFormsForDirectory(directory, pendingForms, serverId)
       } catch (error) {
         if (import.meta.env.DEV) {
           console.warn(`Failed to fetch pending actions for ${directory}:`, error)
@@ -546,7 +635,10 @@ export function EventProvider({ children }: { children: React.ReactNode }) {
     return [...directories]
   }, [])
 
-  const resolveSessionAncestry = useCallback(async (sessionIDs: string[]) => {
+  const resolveSessionAncestry = useCallback(async (
+    sessionIDs: string[],
+    serverId: string = LOCAL_OPENCODE_SERVER_ID,
+  ) => {
     const resolveUp = async (startID: string): Promise<void> => {
       let currentID: string | null = startID
       const visited = new Set<string>()
@@ -564,9 +656,13 @@ export function EventProvider({ children }: { children: React.ReactNode }) {
         const lookupID = currentID
         ancestryInFlightRef.current.add(lookupID)
         try {
-          const session = await getSession(lookupID)
+          const session = await getSession(lookupID, serverId)
           useSessionStatus.getState().setSessionParent(lookupID, session.parentID ?? null)
-          useSessionStatus.getState().setSessionDirectory(lookupID, session.location.directory)
+          useSessionStatus.getState().setSessionServer(lookupID, serverId)
+          useSessionStatus.getState().setSessionDirectory(
+            lookupID,
+            buildServerDirectoryKey(serverId, session.location.directory),
+          )
           currentID = session.parentID ?? null
         } catch (error) {
           if (import.meta.env.DEV) {
@@ -583,17 +679,18 @@ export function EventProvider({ children }: { children: React.ReactNode }) {
   }, [])
 
   const syncRunningShells = useCallback(async (directories: string[]) => {
-    await Promise.all(directories.map(async (directory) => {
+    await Promise.all(directories.map(async (key) => {
+      const { serverId, directory } = parseServerDirectoryKey(key)
       const token = useSessionStatus.getState().beginShellSnapshot()
       try {
-        const shells = await listShells(directory)
+        const shells = await listShells(directory, serverId)
         const runningShells = shells.flatMap((shell) => {
           const sessionID = shell.metadata.sessionID
           if (shell.status !== 'running' || typeof sessionID !== 'string') return []
           return [{ id: shell.id, sessionID }]
         })
-        useSessionStatus.getState().replaceRunningShells(directory, runningShells, token)
-        await resolveSessionAncestry(runningShells.map((shell) => shell.sessionID))
+        useSessionStatus.getState().replaceRunningShells(key, runningShells, token)
+        await resolveSessionAncestry(runningShells.map((shell) => shell.sessionID), serverId)
       } catch (error) {
         useSessionStatus.getState().endShellSnapshot(token)
         if (import.meta.env.DEV) {
@@ -622,7 +719,9 @@ export function EventProvider({ children }: { children: React.ReactNode }) {
       }
       const busyBeforeSnapshot = new Set<string>()
       for (const [sessionID, status] of useSessionStatus.getState().statuses.entries()) {
-        if (status.type !== 'idle') busyBeforeSnapshot.add(sessionID)
+        if (status.type === 'idle') continue
+        if (useSessionStatus.getState().sessionServers.has(sessionID)) continue
+        busyBeforeSnapshot.add(sessionID)
       }
       useSessionStatus.getState().replaceStatuses(
         busyStatusesFromActiveSessions(active),
@@ -644,6 +743,39 @@ export function EventProvider({ children }: { children: React.ReactNode }) {
     }
   }, [queryClient, resolveSessionAncestry])
 
+  const invalidateRemoteStatusSyncs = useCallback(() => {
+    const versions = remoteStatusSyncVersionsRef.current
+    for (const [serverId, version] of versions.entries()) {
+      versions.set(serverId, version + 1)
+    }
+  }, [])
+
+  const reconcileRemoteSessionStatuses = useCallback(async (serverId: string) => {
+    const versions = remoteStatusSyncVersionsRef.current
+    const syncVersion = (versions.get(serverId) ?? 0) + 1
+    versions.set(serverId, syncVersion)
+    const snapshotToken = useSessionStatus.getState().beginStatusSnapshot()
+
+    try {
+      const active = await listActiveSessions(serverId)
+      if (versions.get(serverId) !== syncVersion) {
+        useSessionStatus.getState().endStatusSnapshot(snapshotToken)
+        return
+      }
+      useSessionStatus.getState().replaceServerStatuses(
+        serverId,
+        busyStatusesFromActiveSessions(active),
+        snapshotToken,
+      )
+      await resolveSessionAncestry(Object.keys(active), serverId)
+    } catch (error) {
+      useSessionStatus.getState().endStatusSnapshot(snapshotToken)
+      if (import.meta.env.DEV) {
+        console.warn(`Failed to fetch active sessions for ${serverId}:`, error)
+      }
+    }
+  }, [resolveSessionAncestry])
+
   const stopStatusPoll = useCallback(() => {
     if (statusPollIntervalRef.current === null) return
     clearInterval(statusPollIntervalRef.current)
@@ -657,16 +789,24 @@ export function EventProvider({ children }: { children: React.ReactNode }) {
     }, STATUS_POLL_INTERVAL_MS)
   }, [fetchInitialSessionStatuses, stopStatusPoll])
 
-  const syncPermissionsForSession = useCallback(async (directory: string, sessionID: string) => {
-    const pendingPermissions = await listPendingPermissions(directory)
-    rememberSessionDirectory(sessionID, directory)
-    reconcilePermissionsForDirectory(directory, pendingPermissions)
+  const syncPermissionsForSession = useCallback(async (
+    directory: string,
+    sessionID: string,
+    serverId: string = LOCAL_OPENCODE_SERVER_ID,
+  ) => {
+    const pendingPermissions = await listPendingPermissions(directory, serverId)
+    rememberSessionDirectory(sessionID, directory, serverId)
+    reconcilePermissionsForDirectory(directory, pendingPermissions, serverId)
   }, [rememberSessionDirectory, reconcilePermissionsForDirectory])
 
-  const syncFormsForSession = useCallback(async (directory: string, sessionID: string) => {
-    const pendingForms = await listPendingForms(directory)
-    rememberSessionDirectory(sessionID, directory)
-    reconcileFormsForDirectory(directory, pendingForms)
+  const syncFormsForSession = useCallback(async (
+    directory: string,
+    sessionID: string,
+    serverId: string = LOCAL_OPENCODE_SERVER_ID,
+  ) => {
+    const pendingForms = await listPendingForms(directory, serverId)
+    rememberSessionDirectory(sessionID, directory, serverId)
+    reconcileFormsForDirectory(directory, pendingForms, serverId)
   }, [rememberSessionDirectory, reconcileFormsForDirectory])
 
   useEffect(() => {
@@ -674,14 +814,15 @@ export function EventProvider({ children }: { children: React.ReactNode }) {
       if (!data || typeof data !== 'object' || !('type' in data)) return
       
       const event = data as StreamEvent
+      const serverId = (event as { serverId?: string }).serverId ?? LOCAL_OPENCODE_SERVER_ID
 
       switch (event.type) {
         case 'permission.asked': {
           const request = event.data
-          rememberSessionDirectory(request.sessionID, event.directory)
-          addPermission(request)
+          rememberSessionDirectory(request.sessionID, event.directory, serverId)
+          addPermission(request, serverId)
           if (!useSessionStatus.getState().parents.has(request.sessionID)) {
-            void resolveSessionAncestry([request.sessionID])
+            void resolveSessionAncestry([request.sessionID], serverId)
           }
           break
         }
@@ -692,10 +833,10 @@ export function EventProvider({ children }: { children: React.ReactNode }) {
         }
         case 'form.created': {
           const form = event.data.form
-          rememberSessionDirectory(form.sessionID, event.directory)
-          addForm(form)
+          rememberSessionDirectory(form.sessionID, event.directory, serverId)
+          addForm(form, serverId)
           if (!useSessionStatus.getState().parents.has(form.sessionID)) {
-            void resolveSessionAncestry([form.sessionID])
+            void resolveSessionAncestry([form.sessionID], serverId)
           }
           break
         }
@@ -707,25 +848,25 @@ export function EventProvider({ children }: { children: React.ReactNode }) {
         }
         case 'session.status': {
           const { sessionID, status } = event.data
-          if (event.directory) {
-            useSessionStatus.getState().setSessionDirectory(sessionID, event.directory)
-          }
+          useSessionStatus.getState().setSessionServer(sessionID, serverId)
+          rememberSessionDirectory(sessionID, event.directory, serverId)
           useSessionStatus.getState().setStatus(sessionID, status)
           break
         }
         case 'session.idle': {
+          useSessionStatus.getState().setSessionServer(event.data.sessionID, serverId)
           useSessionStatus.getState().setStatus(event.data.sessionID, { type: 'idle' })
           break
         }
         case 'session.execution.started': {
-          if (event.directory) {
-            useSessionStatus.getState().setSessionDirectory(event.data.sessionID, event.directory)
-          }
+          useSessionStatus.getState().setSessionServer(event.data.sessionID, serverId)
+          rememberSessionDirectory(event.data.sessionID, event.directory, serverId)
           useSessionStatus.getState().clearOutcome(event.data.sessionID)
           useSessionStatus.getState().setStatus(event.data.sessionID, { type: 'busy' })
           break
         }
         case 'session.execution.succeeded': {
+          useSessionStatus.getState().setSessionServer(event.data.sessionID, serverId)
           useSessionStatus.getState().setOutcome(event.data.sessionID, 'succeeded')
           useSessionStatus.getState().setStatus(event.data.sessionID, { type: 'idle' })
           invalidateSessionListCachesDebounced(queryClient, event.directory)
@@ -733,6 +874,7 @@ export function EventProvider({ children }: { children: React.ReactNode }) {
           break
         }
         case 'session.execution.failed': {
+          useSessionStatus.getState().setSessionServer(event.data.sessionID, serverId)
           useSessionStatus.getState().setOutcome(event.data.sessionID, 'failed')
           useSessionStatus.getState().setStatus(event.data.sessionID, { type: 'idle' })
           invalidateSessionListCachesDebounced(queryClient, event.directory)
@@ -740,6 +882,7 @@ export function EventProvider({ children }: { children: React.ReactNode }) {
           break
         }
         case 'session.execution.interrupted': {
+          useSessionStatus.getState().setSessionServer(event.data.sessionID, serverId)
           useSessionStatus.getState().setOutcome(event.data.sessionID, 'interrupted')
           useSessionStatus.getState().setStatus(event.data.sessionID, { type: 'idle' })
           invalidateSessionListCachesDebounced(queryClient, event.directory)
@@ -752,6 +895,7 @@ export function EventProvider({ children }: { children: React.ReactNode }) {
           break
         }
         case 'session.created': {
+          useSessionStatus.getState().setSessionServer(event.data.sessionID, serverId)
           invalidateSessionListCachesDebounced(queryClient, event.directory)
           if (typeof event.data.parentID === 'string') {
             useSessionStatus.getState().setSessionParent(event.data.sessionID, event.data.parentID)
@@ -772,10 +916,14 @@ export function EventProvider({ children }: { children: React.ReactNode }) {
             event.directory
           ) {
             const sessionID = info.metadata.sessionID
-            useSessionStatus.getState().setShellRunning(info.id, sessionID, event.directory)
-            useSessionStatus.getState().setSessionDirectory(sessionID, event.directory)
+            useSessionStatus.getState().setShellRunning(
+              info.id,
+              sessionID,
+              buildServerDirectoryKey(serverId, event.directory),
+            )
+            rememberSessionDirectory(sessionID, event.directory, serverId)
             if (!useSessionStatus.getState().parents.has(sessionID)) {
-              void resolveSessionAncestry([sessionID])
+              void resolveSessionAncestry([sessionID], serverId)
             }
           }
           break
@@ -839,17 +987,34 @@ export function EventProvider({ children }: { children: React.ReactNode }) {
         initialFetchDoneRef.current = false
         fetchInitialPendingData()
         fetchInitialSessionStatuses()
+        for (const server of enabledRemoteServersRef.current) {
+          void reconcileRemoteSessionStatuses(server.id)
+        }
         void syncRunningShells(collectTrackedDirectories())
         invalidateChildSessionCaches(queryClient)
         invalidateQueryKeysDebounced(queryClient, LOCATION_CATALOG_QUERY_KEYS)
         startStatusPoll()
       } else {
         statusSyncVersionRef.current += 1
+        invalidateRemoteStatusSyncs()
         stopStatusPoll()
       }
     }
 
-    const handleResync = (subscribedDirectories: string[]) => {
+    const handleResync = (subscribedDirectories: string[], serverId?: string) => {
+      if (serverId && !isLocalOpenCodeServer(serverId)) {
+        const directories = subscribedDirectories.filter(
+          (key) => parseServerDirectoryKey(key).serverId === serverId,
+        )
+        void reconcilePendingActionsForDirectories(directories)
+        void reconcileRemoteSessionStatuses(serverId)
+        void syncRunningShells(directories)
+        invalidateQueryKeysDebounced(
+          queryClient,
+          LOCATION_CATALOG_QUERY_KEYS.map((key) => serverScopedKey(key, serverId)),
+        )
+        return
+      }
       const directories = [...new Set([...collectTrackedDirectories(), ...subscribedDirectories])]
       void reconcilePendingActionsForDirectories(directories)
       void fetchInitialSessionStatuses()
@@ -874,11 +1039,12 @@ export function EventProvider({ children }: { children: React.ReactNode }) {
     
     return () => {
       statusSyncVersionRef.current += 1
+      invalidateRemoteStatusSyncs()
       stopStatusPoll()
       subscription.dispose()
       subscriptionRef.current = null
     }
-  }, [addPermission, removePermission, addForm, removeForm, rememberSessionDirectory, fetchInitialPendingData, fetchInitialSessionStatuses, startStatusPoll, stopStatusPoll, queryClient, handleHealthChange, reconcilePendingActionsForDirectories, collectTrackedDirectories, syncRunningShells, resolveSessionAncestry])
+  }, [addPermission, removePermission, addForm, removeForm, rememberSessionDirectory, fetchInitialPendingData, fetchInitialSessionStatuses, startStatusPoll, stopStatusPoll, queryClient, handleHealthChange, reconcilePendingActionsForDirectories, collectTrackedDirectories, syncRunningShells, resolveSessionAncestry, reconcileRemoteSessionStatuses, invalidateRemoteStatusSyncs])
 
   useEffect(() => {
     reposRef.current = repos
@@ -886,8 +1052,11 @@ export function EventProvider({ children }: { children: React.ReactNode }) {
     for (const directory of activeSessionDirectoriesKey.split('\n')) {
       if (directory) directories.add(directory)
     }
+    for (const key of remoteProjectDirectoriesKey.split('\n')) {
+      if (key) directories.add(key)
+    }
     subscriptionRef.current?.updateDirectories([...directories])
-  }, [repos, activeSessionDirectoriesKey])
+  }, [repos, activeSessionDirectoriesKey, remoteProjectDirectoriesKey])
 
   useEffect(() => {
     if (!repos || repos.length === 0) return
diff --git a/frontend/src/contexts/OpenCodeServerContext.test.tsx b/frontend/src/contexts/OpenCodeServerContext.test.tsx
new file mode 100644
index 000000000..f97d5a72c
--- /dev/null
+++ b/frontend/src/contexts/OpenCodeServerContext.test.tsx
@@ -0,0 +1,27 @@
+import { renderHook } from '@testing-library/react'
+import { describe, expect, it } from 'vitest'
+import { MemoryRouter } from 'react-router-dom'
+import { LOCAL_OPENCODE_SERVER_ID } from '@opencode-manager/shared/schemas'
+import { useRouteOpenCodeServerId } from './OpenCodeServerContext'
+
+function renderRouteServerId(pathname: string) {
+  return renderHook(() => useRouteOpenCodeServerId(), {
+    wrapper: ({ children }) => <MemoryRouter initialEntries={[pathname]}>{children}</MemoryRouter>,
+  })
+}
+
+describe('useRouteOpenCodeServerId', () => {
+  it('reports the local server outside a linked-server route', () => {
+    expect(renderRouteServerId('/').result.current).toBe(LOCAL_OPENCODE_SERVER_ID)
+    expect(renderRouteServerId('/repos/1/sessions/ses_1').result.current).toBe(LOCAL_OPENCODE_SERVER_ID)
+    expect(renderRouteServerId('/schedules').result.current).toBe(LOCAL_OPENCODE_SERVER_ID)
+  })
+
+  it('reports the server id of a linked-server route', () => {
+    expect(renderRouteServerId('/servers/srv_kitchen').result.current).toBe('srv_kitchen')
+  })
+
+  it('reports the server id of a linked-server session route', () => {
+    expect(renderRouteServerId('/servers/srv_kitchen/sessions/ses_remote').result.current).toBe('srv_kitchen')
+  })
+})
diff --git a/frontend/src/contexts/OpenCodeServerContext.tsx b/frontend/src/contexts/OpenCodeServerContext.tsx
new file mode 100644
index 000000000..1371d66b3
--- /dev/null
+++ b/frontend/src/contexts/OpenCodeServerContext.tsx
@@ -0,0 +1,33 @@
+/* eslint-disable react-refresh/only-export-components */
+import { createContext, useContext } from 'react'
+import { useMatch } from 'react-router-dom'
+import { LOCAL_OPENCODE_SERVER_ID } from '@opencode-manager/shared/schemas'
+
+const OpenCodeServerContext = createContext<string>(LOCAL_OPENCODE_SERVER_ID)
+
+export function isLocalOpenCodeServer(serverId: string): boolean {
+  return serverId === LOCAL_OPENCODE_SERVER_ID
+}
+
+export function OpenCodeServerProvider({
+  serverId,
+  children,
+}: {
+  serverId: string
+  children: React.ReactNode
+}) {
+  return <OpenCodeServerContext.Provider value={serverId}>{children}</OpenCodeServerContext.Provider>
+}
+
+export function useOpenCodeServerId(): string {
+  return useContext(OpenCodeServerContext)
+}
+
+/**
+ * Server id carried by the current route: the `serverId` of a `/servers/:serverId` route, or the
+ * local server id everywhere else. For components rendered outside the server scope provider.
+ */
+export function useRouteOpenCodeServerId(): string {
+  const match = useMatch('/servers/:serverId/*')
+  return match?.params.serverId ?? LOCAL_OPENCODE_SERVER_ID
+}
diff --git a/frontend/src/hooks/__tests__/useCommandHandler.test.tsx b/frontend/src/hooks/__tests__/useCommandHandler.test.tsx
index f9f08b59d..c3f418010 100644
--- a/frontend/src/hooks/__tests__/useCommandHandler.test.tsx
+++ b/frontend/src/hooks/__tests__/useCommandHandler.test.tsx
@@ -113,7 +113,7 @@ describe('useCommandHandler', () => {
       sessionID: 'test-session-id',
       name: 'export',
       text: '',
-    })
+    }, 'local')
     expect(actions.exportSession).not.toHaveBeenCalled()
   })
 
@@ -166,7 +166,7 @@ describe('useCommandHandler', () => {
       sessionID: 'test-session-id',
       name: 'review',
       text: '',
-    })
+    }, 'local')
   })
 
   it('unknown command runs the V2 command with the parsed payload', async () => {
@@ -186,7 +186,7 @@ describe('useCommandHandler', () => {
       files,
       agents,
       skills,
-    })
+    }, 'local')
   })
 
   it('switches model and agent before running the command when the selection changed', async () => {
@@ -203,8 +203,8 @@ describe('useCommandHandler', () => {
       providerID: 'openai',
       id: 'gpt-4',
       variant: 'v1',
-    })
-    expect(mocks.switchSessionAgent).toHaveBeenCalledWith('test-session-id', 'plan')
+    }, 'local')
+    expect(mocks.switchSessionAgent).toHaveBeenCalledWith('test-session-id', 'plan', 'local')
     expect(mocks.switchSessionModel.mock.invocationCallOrder[0]).toBeLessThan(
       mocks.runCommand.mock.invocationCallOrder[0],
     )
diff --git a/frontend/src/hooks/__tests__/useLoadSkill.test.tsx b/frontend/src/hooks/__tests__/useLoadSkill.test.tsx
index 3e5c5d954..a73cbc423 100644
--- a/frontend/src/hooks/__tests__/useLoadSkill.test.tsx
+++ b/frontend/src/hooks/__tests__/useLoadSkill.test.tsx
@@ -52,7 +52,7 @@ describe('useLoadSkill', () => {
     })
 
     expect(mocks.activateSkill).toHaveBeenCalledTimes(1)
-    expect(mocks.activateSkill).toHaveBeenCalledWith('test-session-id', 'my-skill')
+    expect(mocks.activateSkill).toHaveBeenCalledWith('test-session-id', 'my-skill', 'local')
   })
 
   it('throws error when sessionID is undefined', async () => {
diff --git a/frontend/src/hooks/useActiveWork.test.tsx b/frontend/src/hooks/useActiveWork.test.tsx
index 13b62d2e9..3337459b7 100644
--- a/frontend/src/hooks/useActiveWork.test.tsx
+++ b/frontend/src/hooks/useActiveWork.test.tsx
@@ -6,7 +6,7 @@ import type { SessionInfo } from '@opencode-manager/shared/opencode'
 import type { Repo } from '@/api/types'
 import { MS_PER_MINUTE } from '@/lib/activeWork'
 import { useSessionStatus } from '@/stores/sessionStatusStore'
-import { useActiveWork } from './useActiveWork'
+import { useActiveWork, useActiveWorkCounts } from './useActiveWork'
 
 const REPO_PATH = '/repo'
 const WINDOW_MS = 60 * MS_PER_MINUTE
@@ -40,6 +40,13 @@ vi.mock('@/hooks/useSidebarRepoGroups', () => ({
   useNavigableRepos: mocks.useNavigableRepos,
 }))
 
+vi.mock('@/hooks/useOpenCodeServers', () => ({
+  useOpenCodeServers: () => ({
+    servers: [{ id: 'srv_kitchen', name: 'Kitchen', enabled: true }],
+    isLoading: false,
+  }),
+}))
+
 vi.mock('@/contexts/EventContext', () => ({
   usePermissions: () => ({ pendingSessionIDs: mocks.pendingSessionIDs }),
   useForms: () => ({ pendingSessionIDs: mocks.pendingSessionIDs }),
@@ -101,6 +108,7 @@ describe('useActiveWork', () => {
     mocks.getRepoSiblings.mockResolvedValue([])
     mocks.useNavigableRepos.mockReset()
     mocks.useNavigableRepos.mockReturnValue({ repos: [repo], isLoading: false, refetch: vi.fn() })
+    mocks.pendingSessionIDs = []
     useSessionStatus.setState({
       statuses: new Map(),
       statusCache: new Map(),
@@ -109,6 +117,7 @@ describe('useActiveWork', () => {
       outcomes: new Map(),
       parents: new Map(),
       directories: new Map(),
+      sessionServers: new Map(),
       runningShells: new Map(),
       shellRevisions: new Map(),
       shellRevision: 0,
@@ -138,7 +147,7 @@ describe('useActiveWork', () => {
 
     await waitFor(() => expect(recentIDs(result.current.groups)).toContain('root2'))
 
-    expect(mocks.listSessionPage).toHaveBeenCalledWith({ cursor: 'page2', includeChildren: true })
+    expect(mocks.listSessionPage).toHaveBeenCalledWith({ cursor: 'page2', includeChildren: true }, 'local')
   })
 
   it('does not request another page when the oldest loaded session is outside the window', async () => {
@@ -273,4 +282,58 @@ describe('useActiveWork', () => {
 
     expect(mocks.getRepoSiblings).not.toHaveBeenCalled()
   })
+
+  it('counts a remote pending permission and shows one labelled remote row', async () => {
+    const now = Date.now()
+    mocks.pendingSessionIDs = ['ses_remote']
+    mocks.listSessionPage.mockResolvedValue({ items: [] })
+    mocks.getSession.mockResolvedValue(session('ses_remote', now - 500, null, '/home/me/app'))
+    useSessionStatus.setState({
+      sessionServers: new Map([['ses_remote', 'srv_kitchen']]),
+      directories: new Map([['ses_remote', 'srv_kitchen|/home/me/app']]),
+    })
+
+    const { result } = renderHook(
+      () => ({ work: useActiveWork(WINDOW_MS), counts: useActiveWorkCounts() }),
+      { wrapper: createWrapper(createQueryClient()) },
+    )
+
+    await waitFor(() => expect(result.current.work.groups.needsInput).toHaveLength(1))
+
+    const row = result.current.work.groups.needsInput[0]
+    expect(result.current.counts).toEqual({ needsInput: 1, running: 0 })
+    expect(row.serverId).toBe('srv_kitchen')
+    expect(row.serverName).toBe('Kitchen')
+    expect(row.repo).toBeNull()
+    expect(row.path).toBe('/servers/srv_kitchen/sessions/ses_remote')
+  })
+
+  it('renders a running remote session row and resolves its ancestry on the owning server', async () => {
+    const now = Date.now()
+    mocks.listSessionPage.mockResolvedValue({ items: [] })
+    mocks.getSession.mockImplementation(async (id: string, serverId?: string) => {
+      if (serverId !== 'srv_kitchen') throw new Error('local lookup for a remote session')
+      if (id === 'ses_child') return session('ses_child', now - 1000, 'ses_remote', '/home/me/app')
+      if (id === 'ses_remote') return session('ses_remote', now - 4000, null, '/home/me/app')
+      throw new Error(`unexpected session ${id}`)
+    })
+    useSessionStatus.setState({
+      statuses: new Map([['ses_child', { type: 'busy' }]]),
+      sessionServers: new Map([['ses_child', 'srv_kitchen']]),
+      directories: new Map([['ses_child', 'srv_kitchen|/home/me/app']]),
+    })
+
+    const { result } = renderHook(
+      () => ({ work: useActiveWork(WINDOW_MS), counts: useActiveWorkCounts() }),
+      { wrapper: createWrapper(createQueryClient()) },
+    )
+
+    await waitFor(() => expect(result.current.work.groups.running).toHaveLength(1))
+
+    expect(result.current.counts).toEqual({ needsInput: 0, running: 1 })
+    expect(result.current.work.groups.running[0].session.id).toBe('ses_remote')
+    expect(result.current.work.groups.running[0].serverName).toBe('Kitchen')
+    expect(mocks.getSession).toHaveBeenCalledWith('ses_child', 'srv_kitchen')
+    expect(mocks.getSession).not.toHaveBeenCalledWith('ses_child', 'local')
+  })
 })
diff --git a/frontend/src/hooks/useActiveWork.ts b/frontend/src/hooks/useActiveWork.ts
index 5be838ff2..0e4a8dcd0 100644
--- a/frontend/src/hooks/useActiveWork.ts
+++ b/frontend/src/hooks/useActiveWork.ts
@@ -1,10 +1,13 @@
 import { useEffect, useMemo, useState } from 'react'
 import { useQueries, useQueryClient, type QueryClient } from '@tanstack/react-query'
+import { LOCAL_OPENCODE_SERVER_ID, parseServerDirectoryKey } from '@opencode-manager/shared/schemas'
 import type { SessionInfo } from '@opencode-manager/shared/opencode'
 import { sessionQueryOptions, useSessionsAcrossDirectories } from '@/hooks/useOpenCode'
 import { useNavigableRepos } from '@/hooks/useSidebarRepoGroups'
 import { usePendingInputSessionIDs, useRepoWorktreeList } from '@/contexts/RepoWorktreesContext'
 import { useSessionStatus } from '@/stores/sessionStatusStore'
+import { useOpenCodeServers } from '@/hooks/useOpenCodeServers'
+import { serverScopedKey } from '@/lib/serverScope'
 import { useSettings } from '@/hooks/useSettings'
 import { DEFAULT_ACTIVITY_WINDOW_MINUTES } from '@/api/types/settings'
 import { useRepoWorktrees } from '@/hooks/useRepoWorktrees'
@@ -77,24 +80,52 @@ export function useRepoActivityState(repo: Repo): 'needs-input' | 'running' | nu
   )
 }
 
+interface SessionScope {
+  serverId: string
+  directory: string | undefined
+}
+
+/**
+ * The owning server and plain directory of a session from the status store. A server-keyed
+ * directory names its owner, otherwise the session-server index does; everything else is local.
+ */
+function sessionScopeOf(
+  sessionID: string,
+  directories: ReadonlyMap<string, string>,
+  sessionServers: ReadonlyMap<string, string>,
+): SessionScope {
+  const directoryKey = directories.get(sessionID)
+  const parsed = directoryKey ? parseServerDirectoryKey(directoryKey) : null
+  const serverId =
+    parsed && parsed.serverId !== LOCAL_OPENCODE_SERVER_ID
+      ? parsed.serverId
+      : sessionServers.get(sessionID) ?? LOCAL_OPENCODE_SERVER_ID
+  return { serverId, directory: parsed?.directory }
+}
+
 /**
  * Walks a session's ancestor chain through the shared session cache, returning each link as
  * `[sessionID, parentID]` from the session down to its root. Stops at a root, a missing session,
- * or a cycle. Reusing `sessionQueryOptions` keeps these reads on the shared session cache.
+ * or a cycle. Remote sessions are read through their owning server, never the local API. Reusing
+ * `sessionQueryOptions` keeps these reads on the shared session cache.
  */
 async function fetchAncestorLinks(
   queryClient: QueryClient,
   sessionID: string,
   directories: ReadonlyMap<string, string>,
+  sessionServers: ReadonlyMap<string, string>,
 ): Promise<Array<[string, string | null]>> {
   const links: Array<[string, string | null]> = []
   const visited = new Set<string>()
+  const origin = sessionScopeOf(sessionID, directories, sessionServers)
   let currentID: string | null | undefined = sessionID
 
   while (currentID && !visited.has(currentID)) {
     visited.add(currentID)
+    const scope = sessionScopeOf(currentID, directories, sessionServers)
+    const directory = scope.serverId === origin.serverId ? scope.directory : undefined
     const session: SessionInfo = await queryClient.fetchQuery(
-      sessionQueryOptions(currentID, directories.get(currentID)),
+      sessionQueryOptions(currentID, directory, origin.serverId),
     )
     const parentID: string | null = session.parentID ?? null
     links.push([session.id, parentID])
@@ -135,6 +166,7 @@ export function useActiveWork(windowMs: number): {
     allDirectories: true,
     limit: ACTIVE_WORK_SESSION_LIMIT,
     includeChildren: true,
+    serverId: LOCAL_OPENCODE_SERVER_ID,
   })
 
   useEffect(() => {
@@ -163,6 +195,7 @@ export function useActiveWork(windowMs: number): {
   const runningShells = useSessionStatus((state) => state.runningShells)
   const outcomes = useSessionStatus((state) => state.outcomes)
   const sessionDirectories = useSessionStatus((state) => state.directories)
+  const sessionServers = useSessionStatus((state) => state.sessionServers)
   const pendingInputSessionIDs = usePendingInputSessionIDs()
 
   const parents = useMemo(() => {
@@ -204,11 +237,14 @@ export function useActiveWork(windowMs: number): {
   }, [sessions, parents, listedSessionIDs, roots, windowMs, now])
 
   const ancestorLinks = useQueries({
-    queries: missingRootIDs.map((sessionID) => ({
-      queryKey: ['opencode', 'session-ancestry', sessionID] as const,
-      queryFn: () => fetchAncestorLinks(queryClient, sessionID, sessionDirectories),
-      staleTime: Infinity,
-    })),
+    queries: missingRootIDs.map((sessionID) => {
+      const { serverId } = sessionScopeOf(sessionID, sessionDirectories, sessionServers)
+      return {
+        queryKey: serverScopedKey(['opencode', 'session-ancestry', sessionID], serverId),
+        queryFn: () => fetchAncestorLinks(queryClient, sessionID, sessionDirectories, sessionServers),
+        staleTime: Infinity,
+      }
+    }),
     combine: combineAncestorLinks,
   })
 
@@ -225,6 +261,35 @@ export function useActiveWork(windowMs: number): {
     [statuses, resolvedParents, runningShells, pendingInputSessionIDs],
   )
 
+  const resolvedSessionServers = useMemo(() => {
+    const merged = new Map(sessionServers)
+    for (const [sessionID, serverId] of sessionServers) {
+      const visited = new Set<string>()
+      let currentID: string | null | undefined = sessionID
+      while (currentID && !visited.has(currentID)) {
+        visited.add(currentID)
+        merged.set(currentID, serverId)
+        currentID = resolvedParents.get(currentID) ?? null
+      }
+    }
+    return merged
+  }, [sessionServers, resolvedParents])
+
+  const hasRemoteRoots = useMemo(
+    () =>
+      [...resolvedRoots.needsInput, ...resolvedRoots.running].some((sessionID) =>
+        resolvedSessionServers.has(sessionID),
+      ),
+    [resolvedRoots, resolvedSessionServers],
+  )
+
+  const { servers } = useOpenCodeServers({ enabled: hasRemoteRoots })
+
+  const serverNames = useMemo(() => {
+    if (!hasRemoteRoots || servers.length === 0) return undefined
+    return new Map(servers.map((server) => [server.id, server.name]))
+  }, [hasRemoteRoots, servers])
+
   const backfillRootIDs = useMemo(() => {
     const ids = new Set<string>()
     for (const sessionID of missingRootIDs) {
@@ -235,9 +300,10 @@ export function useActiveWork(windowMs: number): {
   }, [missingRootIDs, resolvedParents, listedSessionIDs])
 
   const fetchedSessions = useQueries({
-    queries: backfillRootIDs.map((sessionID) =>
-      sessionQueryOptions(sessionID, sessionDirectories.get(sessionID)),
-    ),
+    queries: backfillRootIDs.map((sessionID) => {
+      const { serverId, directory } = sessionScopeOf(sessionID, sessionDirectories, resolvedSessionServers)
+      return sessionQueryOptions(sessionID, directory, serverId)
+    }),
     combine: combineQuerySessions,
   })
 
@@ -255,8 +321,9 @@ export function useActiveWork(windowMs: number): {
         sessions: mergedSessions,
         parents: resolvedParents,
         roots: resolvedRoots,
+        sessionServers: resolvedSessionServers,
       }),
-    [now, windowMs, repos, mergedSessions, resolvedParents, resolvedRoots],
+    [now, windowMs, repos, mergedSessions, resolvedParents, resolvedRoots, resolvedSessionServers],
   )
 
   const {
@@ -276,8 +343,21 @@ export function useActiveWork(windowMs: number): {
         roots: resolvedRoots,
         outcomes,
         worktrees,
+        sessionServers: resolvedSessionServers,
+        serverNames,
       }),
-    [now, windowMs, repos, mergedSessions, resolvedParents, resolvedRoots, outcomes, worktrees],
+    [
+      now,
+      windowMs,
+      repos,
+      mergedSessions,
+      resolvedParents,
+      resolvedRoots,
+      outcomes,
+      worktrees,
+      resolvedSessionServers,
+      serverNames,
+    ],
   )
 
   return {
diff --git a/frontend/src/hooks/useCommandHandler.ts b/frontend/src/hooks/useCommandHandler.ts
index cae58dd2a..fd7ef69b7 100644
--- a/frontend/src/hooks/useCommandHandler.ts
+++ b/frontend/src/hooks/useCommandHandler.ts
@@ -1,6 +1,7 @@
 import { useCallback } from 'react'
 import { runCommand } from '@/api/opencode'
 import type { PromptAgentInput, PromptFileInput, PromptSkillInput } from '@/api/opencode'
+import { useOpenCodeServerId } from '@/contexts/OpenCodeServerContext'
 import { useSyncSessionSelection } from '@/hooks/useOpenCode'
 import { showToast } from '@/lib/toast'
 import type { CommandInfo, ModelRef } from '@opencode-manager/shared/opencode'
@@ -29,6 +30,7 @@ export function useCommandHandler({
   currentAgent,
   actions,
 }: CommandHandlerProps) {
+  const serverId = useOpenCodeServerId()
   const syncSelection = useSyncSessionSelection(directory)
   const setSessionStatus = useSessionStatus((state) => state.setStatus)
 
@@ -45,21 +47,24 @@ export function useCommandHandler({
 
     try {
       await syncSelection({ sessionID, model, agent: currentAgent })
-      await runCommand({
-        sessionID,
-        name: command.name,
-        text: submission.text,
-        ...(submission.files ? { files: submission.files } : {}),
-        ...(submission.agents ? { agents: submission.agents } : {}),
-        ...(submission.skills ? { skills: submission.skills } : {}),
-      })
+      await runCommand(
+        {
+          sessionID,
+          name: command.name,
+          text: submission.text,
+          ...(submission.files ? { files: submission.files } : {}),
+          ...(submission.agents ? { agents: submission.agents } : {}),
+          ...(submission.skills ? { skills: submission.skills } : {}),
+        },
+        serverId,
+      )
       return true
     } catch (error) {
       showToast.error(`Command failed: ${error instanceof Error ? error.message : 'Unknown error'}`)
       setSessionStatus(sessionID, { type: 'idle' })
       return false
     }
-  }, [actions, sessionID, model, syncSelection, currentAgent, setSessionStatus])
+  }, [actions, sessionID, model, syncSelection, currentAgent, setSessionStatus, serverId])
 
   return {
     executeCommand
diff --git a/frontend/src/hooks/useCommands.test.tsx b/frontend/src/hooks/useCommands.test.tsx
index faec4757c..c7c2a9070 100644
--- a/frontend/src/hooks/useCommands.test.tsx
+++ b/frontend/src/hooks/useCommands.test.tsx
@@ -4,20 +4,23 @@ import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
 import { useCommands } from './useCommands'
 import { listCommands } from '../api/opencode'
 import { BUILTIN_COMMANDS } from '@/lib/builtinCommands'
+import { OpenCodeServerProvider } from '@/contexts/OpenCodeServerContext'
 import { useRecentCommandsStore } from '@/stores/recentCommandsStore'
 
 vi.mock('../api/opencode', () => ({
   listCommands: vi.fn(),
 }))
 
-const createWrapper = () => {
+const createWrapper = (serverId?: string) => {
   const queryClient = new QueryClient({
     defaultOptions: {
       queries: { retry: false },
     },
   })
   return ({ children }: { children: React.ReactNode }) => (
-    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+    <QueryClientProvider client={queryClient}>
+      {serverId ? <OpenCodeServerProvider serverId={serverId}>{children}</OpenCodeServerProvider> : children}
+    </QueryClientProvider>
   )
 }
 
@@ -74,7 +77,7 @@ describe('useCommands', () => {
       ])
     })
 
-    expect(listCommands).toHaveBeenCalledWith('/repo')
+    expect(listCommands).toHaveBeenCalledWith('/repo', 'local')
   })
 
   it('lets a loaded command override a built-in command with the same name', async () => {
@@ -148,7 +151,7 @@ describe('useCommands', () => {
     rerender({ directory: '/repo-b' })
 
     await waitFor(() => expect(result.current.findCommand('from-b')).toBeDefined())
-    expect(listCommands).toHaveBeenCalledWith('/repo-b')
+    expect(listCommands).toHaveBeenCalledWith('/repo-b', 'local')
   })
 
   it('finds only exact command names, ignoring case', () => {
@@ -157,4 +160,35 @@ describe('useCommands', () => {
     expect(result.current.findCommand('UNDO')?.name).toBe('undo')
     expect(result.current.findCommand('und')).toBeUndefined()
   })
+
+  it('keeps remote-capable built-ins and omits Manager-only ones for a linked server', () => {
+    const { result } = renderHook(() => useCommands({ enabled: false }), {
+      wrapper: createWrapper('srv_kitchen'),
+    })
+
+    const names = result.current.searchCommands('').map(({ item }) => item.name)
+
+    expect(names).not.toContain('sessions')
+    expect(names).not.toContain('resume')
+    expect(names).not.toContain('continue')
+    expect(names).not.toContain('walkthrough')
+    expect(names).toContain('mcp')
+    expect(names).toContain('skills')
+    expect(names).toContain('models')
+    expect(names).toContain('compact')
+    expect(result.current.findCommand('mcp')).toBeDefined()
+  })
+
+  it('keeps Manager-only built-ins for the local server', () => {
+    const { result } = renderHook(() => useCommands({ enabled: false }), {
+      wrapper: createWrapper('local'),
+    })
+
+    const names = result.current.searchCommands('').map(({ item }) => item.name)
+
+    expect(names).toContain('sessions')
+    expect(names).toContain('mcp')
+    expect(names).toContain('skills')
+    expect(names).toContain('walkthrough')
+  })
 })
diff --git a/frontend/src/hooks/useCommands.ts b/frontend/src/hooks/useCommands.ts
index bdc0f2ab9..1d0ff5204 100644
--- a/frontend/src/hooks/useCommands.ts
+++ b/frontend/src/hooks/useCommands.ts
@@ -1,8 +1,10 @@
-import { useCallback } from 'react'
+import { useCallback, useMemo } from 'react'
 import { useQuery } from '@tanstack/react-query'
 import { listCommands } from '@/api/opencode'
+import { isLocalOpenCodeServer, useOpenCodeServerId } from '@/contexts/OpenCodeServerContext'
+import { serverScopedKey } from '@/lib/serverScope'
 import type { CommandInfo } from '@opencode-manager/shared/opencode'
-import { BUILTIN_COMMANDS } from '@/lib/builtinCommands'
+import { getBuiltinCommands } from '@/lib/builtinCommands'
 import { rankByMatch } from '@/lib/fuzzyMatch'
 import { useRecentCommandsStore } from '@/stores/recentCommandsStore'
 
@@ -10,8 +12,6 @@ function sortCommandsByName(commands: CommandInfo[]): CommandInfo[] {
   return [...commands].sort((a, b) => a.name.localeCompare(b.name))
 }
 
-const SORTED_BUILTIN_COMMANDS = sortCommandsByName([...BUILTIN_COMMANDS])
-
 interface UseCommandsOptions {
   directory?: string
   enabled?: boolean
@@ -19,20 +19,27 @@ interface UseCommandsOptions {
 
 export function useCommands(options: UseCommandsOptions = {}) {
   const { directory, enabled = true } = options
+  const serverId = useOpenCodeServerId()
   const recentNames = useRecentCommandsStore((state) => state.names)
 
+  const builtinCommands = useMemo(
+    () => getBuiltinCommands(isLocalOpenCodeServer(serverId)),
+    [serverId],
+  )
+  const sortedBuiltinCommands = useMemo(() => sortCommandsByName([...builtinCommands]), [builtinCommands])
+
   const { data: commands, isLoading: loading, error } = useQuery({
-    queryKey: ['opencode', 'commands', directory ?? null],
+    queryKey: serverScopedKey(['opencode', 'commands', directory ?? null], serverId),
     queryFn: async () => {
-      const loaded = await listCommands(directory)
-      const allCommands = [...loaded, ...BUILTIN_COMMANDS]
+      const loaded = await listCommands(directory, serverId)
+      const allCommands = [...loaded, ...builtinCommands]
       const uniqueCommands = allCommands.filter((command, index, self) =>
         index === self.findIndex((c) => c.name === command.name)
       )
       return sortCommandsByName(uniqueCommands)
     },
     enabled,
-    initialData: SORTED_BUILTIN_COMMANDS,
+    initialData: sortedBuiltinCommands,
     initialDataUpdatedAt: 0,
   })
 
diff --git a/frontend/src/hooks/useContextUsage.ts b/frontend/src/hooks/useContextUsage.ts
index a12ba5f1c..171518125 100644
--- a/frontend/src/hooks/useContextUsage.ts
+++ b/frontend/src/hooks/useContextUsage.ts
@@ -3,7 +3,9 @@ import { skipToken, useQuery } from '@tanstack/react-query'
 import { findModelInfo } from '@opencode-manager/shared/opencode'
 import type { SessionMessageInfo } from '@opencode-manager/shared/opencode'
 import { useProviders } from '@/hooks/useProviders'
+import { useOpenCodeServerId } from '@/contexts/OpenCodeServerContext'
 import { sessionTranscriptQueryKey } from '@/lib/queryInvalidation'
+import { serverScopedKey } from '@/lib/serverScope'
 import type { TranscriptCache } from '@/lib/session-projection'
 
 export interface ContextUsage {
@@ -37,8 +39,9 @@ export const useContextUsage = (
   directory?: string,
   revertMessageID?: string,
 ): ContextUsageResult => {
+  const serverId = useOpenCodeServerId()
   const transcriptQuery = useQuery<TranscriptCache>({
-    queryKey: sessionTranscriptQueryKey(sessionID ?? ''),
+    queryKey: serverScopedKey(sessionTranscriptQueryKey(sessionID ?? ''), serverId),
     queryFn: skipToken,
   })
   const transcriptData = transcriptQuery.data
diff --git a/frontend/src/hooks/useFileSearch.ts b/frontend/src/hooks/useFileSearch.ts
index f1e1b4049..6cbc95be3 100644
--- a/frontend/src/hooks/useFileSearch.ts
+++ b/frontend/src/hooks/useFileSearch.ts
@@ -1,6 +1,8 @@
 import { useQuery } from '@tanstack/react-query'
 import { useDebouncedValue } from '@/hooks/useDebouncedValue'
 import { findFiles } from '@/api/opencode'
+import { useOpenCodeServerId } from '@/contexts/OpenCodeServerContext'
+import { serverScopedKey } from '@/lib/serverScope'
 
 export interface FileSearchResult {
   files: string[]
@@ -13,11 +15,12 @@ export function useFileSearch(
   enabled: boolean = true,
   directory?: string
 ): FileSearchResult {
+  const serverId = useOpenCodeServerId()
   const debouncedQuery = useDebouncedValue(query, 300)
 
   const { data, isLoading, error } = useQuery({
-    queryKey: ['file-search', debouncedQuery, directory],
-    queryFn: () => findFiles({ directory, query: debouncedQuery }),
+    queryKey: serverScopedKey(['file-search', debouncedQuery, directory], serverId),
+    queryFn: () => findFiles({ directory, query: debouncedQuery }, serverId),
     enabled: enabled && !!debouncedQuery,
     staleTime: 60000,
   })
diff --git a/frontend/src/hooks/useGlobalShortcutActions.test.tsx b/frontend/src/hooks/useGlobalShortcutActions.test.tsx
index b166cfc13..75390fdf8 100644
--- a/frontend/src/hooks/useGlobalShortcutActions.test.tsx
+++ b/frontend/src/hooks/useGlobalShortcutActions.test.tsx
@@ -125,10 +125,24 @@ describe('useGlobalShortcutActions', () => {
     pressKey({ key: 'o', ctrlKey: true })
     pressKey({ key: 'n' })
 
-    await waitFor(() => expect(mocks.createSession).toHaveBeenCalledWith({ directory: '/repo/five' }))
+    await waitFor(() => expect(mocks.createSession).toHaveBeenCalledWith({ directory: '/repo/five' }, 'local'))
     await waitFor(() => expect(location()).toBe('/repos/5/sessions/session-new'))
   })
 
+  it('ignores the terminal and source-control shortcuts on a linked-server route', async () => {
+    const { location } = renderHarness('/servers/srv_kitchen/sessions/ses_1')
+
+    pressLeaderFollowUp('t')
+    pressLeaderFollowUp('b')
+
+    await act(async () => {
+      await Promise.resolve()
+    })
+
+    expect(location()).toBe('/servers/srv_kitchen/sessions/ses_1')
+    expect(mocks.getRepo).not.toHaveBeenCalled()
+  })
+
   it('does not swallow the follow-up key when the route has no new-session host', async () => {
     renderHarness('/')
 
diff --git a/frontend/src/hooks/useGlobalShortcutActions.ts b/frontend/src/hooks/useGlobalShortcutActions.ts
index 56befd1fe..989d7ef96 100644
--- a/frontend/src/hooks/useGlobalShortcutActions.ts
+++ b/frontend/src/hooks/useGlobalShortcutActions.ts
@@ -11,6 +11,7 @@ import { useMobile } from '@/hooks/useMobile'
 import { useSettingsDialog } from '@/hooks/useSettingsDialog'
 import { useUrlParams } from '@/hooks/useUrlParams'
 import { toggleToolDialogParams, toggleToolPanelParams, type PanelTool } from '@/hooks/useToolPanel'
+import { isLocalOpenCodeServer, useRouteOpenCodeServerId } from '@/contexts/OpenCodeServerContext'
 import { getAssistantPath, getRepoPath, getSessionPath, isAssistantPath, parseRepoRoute } from '@/lib/navigation'
 
 /**
@@ -23,6 +24,7 @@ export function useGlobalShortcutActions(): void {
   const { updateParams } = useUrlParams()
   const { open: openSettings } = useSettingsDialog()
   const isMobile = useMobile()
+  const isRemoteRoute = !isLocalOpenCodeServer(useRouteOpenCodeServerId())
 
   const repoId = isAssistantPath(pathname) ? ASSISTANT_REPO_ID : parseRepoRoute(pathname).repoId
 
@@ -41,6 +43,7 @@ export function useGlobalShortcutActions(): void {
   const hasFilesTool = toolItems.some((item) => toolKeyOf(item) === 'files')
 
   const toggleRouteTool = useCallback((tool: PanelTool) => {
+    if (isRemoteRoute) return
     if (toolItems.some((item) => toolKeyOf(item) === tool)) {
       updateParams((params) => {
         if (isMobile) toggleToolDialogParams(params, tool)
@@ -51,7 +54,7 @@ export function useGlobalShortcutActions(): void {
     if (tool === 'files') return
     const host = repoId !== null ? getRepoPath(repoId) : getAssistantPath()
     navigate(`${host}${dialogSearch(tool)}`)
-  }, [toolItems, isMobile, updateParams, navigate, repoId])
+  }, [toolItems, isMobile, updateParams, navigate, repoId, isRemoteRoute])
 
   const newSession = repoId !== null && repo?.fullPath && !createSession.isPending
     ? () => createSession.mutate({})
diff --git a/frontend/src/hooks/useMcpServers.ts b/frontend/src/hooks/useMcpServers.ts
index 264f3d006..24ebfe8c7 100644
--- a/frontend/src/hooks/useMcpServers.ts
+++ b/frontend/src/hooks/useMcpServers.ts
@@ -1,20 +1,24 @@
 import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
 import { mcpApi } from '@/api/mcp'
+import { useOpenCodeServerId } from '@/contexts/OpenCodeServerContext'
 import { invalidateSessionCaches } from '@/lib/queryInvalidation'
+import { serverScopedKey } from '@/lib/serverScope'
 import { showToast as toast } from '@/lib/toast'
 
 export function useMcpServers() {
   const queryClient = useQueryClient()
+  const serverId = useOpenCodeServerId()
+  const statusQueryKey = serverScopedKey(['mcp-status'], serverId)
 
   const statusQuery = useQuery({
-    queryKey: ['mcp-status'],
-    queryFn: () => mcpApi.getStatus(),
+    queryKey: statusQueryKey,
+    queryFn: () => mcpApi.getStatus(undefined, serverId),
     refetchInterval: 5000,
     staleTime: 2000,
   })
 
   const connectMutation = useMutation({
-    mutationFn: (name: string) => mcpApi.connect(name),
+    mutationFn: (name: string) => mcpApi.connect(name, undefined, serverId),
     onSuccess: () => {
       queryClient.invalidateQueries({ queryKey: ['mcp-status'] })
       invalidateSessionCaches(queryClient)
@@ -26,7 +30,7 @@ export function useMcpServers() {
   })
 
   const disconnectMutation = useMutation({
-    mutationFn: (name: string) => mcpApi.disconnect(name),
+    mutationFn: (name: string) => mcpApi.disconnect(name, undefined, serverId),
     onSuccess: () => {
       queryClient.invalidateQueries({ queryKey: ['mcp-status'] })
       invalidateSessionCaches(queryClient)
diff --git a/frontend/src/hooks/useModelSelection.test.tsx b/frontend/src/hooks/useModelSelection.test.tsx
index e875a521b..eebcc9cf8 100644
--- a/frontend/src/hooks/useModelSelection.test.tsx
+++ b/frontend/src/hooks/useModelSelection.test.tsx
@@ -3,7 +3,8 @@ import { act, renderHook, waitFor } from '@testing-library/react'
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
 import { useModelSelection, useOpenCodeDefaultModel } from './useModelSelection'
 import { useProviders } from './useProviders'
-import { useModelStore, type ModelSelection } from '@/stores/modelStore'
+import { locationAgentKey, useModelStore, type ModelSelection } from '@/stores/modelStore'
+import { OpenCodeServerProvider } from '@/contexts/OpenCodeServerContext'
 import * as providersApi from '@/api/providers'
 import type { Provider } from '@/api/providers'
 import type { ModelInfo } from '@opencode-manager/shared/opencode'
@@ -482,6 +483,107 @@ describe('useModelSelection', () => {
     })
   })
 
+  describe('remote server scoping', () => {
+    const REMOTE_SERVER_ID = 'srv_remote'
+    const catalog = {
+      providers: [
+        provider('anthropic', 'Anthropic', ['claude-sonnet-4']),
+        provider('openai', 'OpenAI', ['gpt-4o']),
+      ],
+      models: [modelInfo('anthropic', 'claude-sonnet-4'), modelInfo('openai', 'gpt-4o')],
+    }
+
+    const renderRemote = (directory = '/test') => {
+      const queryClient = createTestQueryClient()
+      return renderHook(
+        () => useModelSelection(directory),
+        {
+          wrapper: ({ children }) => (
+            <QueryClientProvider client={queryClient}>
+              <OpenCodeServerProvider serverId={REMOTE_SERVER_ID}>{children}</OpenCodeServerProvider>
+            </QueryClientProvider>
+          ),
+        },
+      )
+    }
+
+    beforeEach(() => {
+      mockGetProviders.mockResolvedValue(catalog)
+      useModelStore.getState().setActiveAgent({ id: 'build' })
+    })
+
+    it('keys new-session picks by the remote server and directory', async () => {
+      const { result } = renderRemote()
+
+      await waitFor(() => {
+        expect(result.current.model).not.toBeNull()
+      })
+
+      act(() => {
+        result.current.setModel({ providerID: 'openai', modelID: 'gpt-4o' })
+      })
+
+      expect(
+        useModelStore.getState().newSessionPicks[locationAgentKey(`${REMOTE_SERVER_ID}|/test`, 'build')],
+      ).toEqual({ providerID: 'openai', modelID: 'gpt-4o' })
+      expect(
+        useModelStore.getState().newSessionPicks[locationAgentKey('/test', 'build')],
+      ).toBeUndefined()
+    })
+
+    it('does not read or write the local model state', async () => {
+      const { result } = renderRemote()
+
+      await waitFor(() => {
+        expect(result.current.isModelReady).toBe(true)
+      })
+
+      act(() => {
+        result.current.setModel({ providerID: 'openai', modelID: 'gpt-4o' })
+        result.current.toggleFavorite({ providerID: 'openai', modelID: 'gpt-4o' })
+        result.current.removeRecentModel({ providerID: 'openai', modelID: 'gpt-4o' })
+      })
+
+      expect(mockGetOpenCodeModelState).not.toHaveBeenCalled()
+      expect(mockAddOpenCodeRecentModel).not.toHaveBeenCalled()
+      expect(mockToggleOpenCodeFavoriteModel).not.toHaveBeenCalled()
+      expect(mockRemoveOpenCodeRecentModel).not.toHaveBeenCalled()
+      expect(result.current.recentModels).toEqual([])
+      expect(result.current.favoriteModels).toEqual([])
+      expect(result.current.modelState).toBeUndefined()
+    })
+
+    it('ignores local recents in the selection order', async () => {
+      mockGetOpenCodeConfiguredModel.mockResolvedValue('anthropic/claude-sonnet-4')
+      mockGetOpenCodeModelState.mockResolvedValue({
+        recent: [{ providerID: 'openai', modelID: 'gpt-4o' }],
+        favorite: [],
+        variant: { 'openai/gpt-4o': 'high' },
+      })
+
+      const { result } = renderRemote()
+
+      await waitFor(() => {
+        expect(result.current.model).toEqual({ providerID: 'anthropic', modelID: 'claude-sonnet-4' })
+      })
+      expect(result.current.recentModels).toEqual([])
+    })
+
+    it('keeps the agent model ahead of the configured model', async () => {
+      mockGetOpenCodeConfiguredModel.mockResolvedValue('openai/gpt-4o')
+      useModelStore.getState().setActiveAgent({
+        id: 'build',
+        model: { providerID: 'anthropic', id: 'claude-sonnet-4' },
+      })
+
+      const { result } = renderRemote()
+
+      await waitFor(() => {
+        expect(result.current.model).toEqual({ providerID: 'anthropic', modelID: 'claude-sonnet-4' })
+      })
+    })
+  })
+
   it('records a recent on setModel', async () => {
     mockGetProviders.mockResolvedValue({ providers: [], models: [] })
 
diff --git a/frontend/src/hooks/useModelSelection.ts b/frontend/src/hooks/useModelSelection.ts
index a1271ec98..9575dd98e 100644
--- a/frontend/src/hooks/useModelSelection.ts
+++ b/frontend/src/hooks/useModelSelection.ts
@@ -1,6 +1,9 @@
 import { useMemo } from 'react'
 import { keepPreviousData, useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
 import { locationAgentKey, useModelStore, type ActiveAgent, type ModelPick, type ModelSelection } from '@/stores/modelStore'
+import { isLocalOpenCodeServer, useOpenCodeServerId } from '@/contexts/OpenCodeServerContext'
+import { serverScopedKey } from '@/lib/serverScope'
+import { buildServerDirectoryKey } from '@opencode-manager/shared/schemas'
 import { useProviders } from './useProviders'
 import { isModelAvailable } from '@/lib/modelCatalog'
 import {
@@ -59,30 +62,33 @@ export function modelStateQueryKey() {
 }
 
 export function useOpenCodeModelState(_directory?: string, enabled = true) {
+  const serverId = useOpenCodeServerId()
   return useQuery({
-    queryKey: modelStateQueryKey(),
+    queryKey: serverScopedKey(modelStateQueryKey(), serverId),
     queryFn: () => getOpenCodeModelState(),
     staleTime: 30000,
     placeholderData: keepPreviousData,
-    enabled,
+    enabled: enabled && isLocalOpenCodeServer(serverId),
   })
 }
 
 function useOpenCodeConfiguredModel(directory?: string, enabled = true) {
+  const serverId = useOpenCodeServerId()
   return useQuery({
-    queryKey: ['opencode', 'config', 'model', directory],
-    queryFn: () => getOpenCodeConfiguredModel(directory),
+    queryKey: serverScopedKey(['opencode', 'config', 'model', directory], serverId),
+    queryFn: () => getOpenCodeConfiguredModel(directory, serverId),
     staleTime: 30000,
     enabled,
   })
 }
 
 export function useOpenCodeDefaultModel(directory?: string, enabled = true) {
+  const serverId = useOpenCodeServerId()
   const providersQuery = useProviders(directory, { enabled })
   const configuredQuery = useOpenCodeConfiguredModel(directory, enabled)
   const defaultQuery = useQuery({
-    queryKey: ['opencode', 'providers', 'default-model', directory],
-    queryFn: () => getOpenCodeServerDefaultModel(directory),
+    queryKey: serverScopedKey(['opencode', 'providers', 'default-model', directory], serverId),
+    queryFn: () => getOpenCodeServerDefaultModel(directory, serverId),
     staleTime: 30000,
     enabled,
   })
@@ -117,22 +123,23 @@ export function useModelStateMutation<TInput>(
   errorMessage: string,
 ) {
   const queryClient = useQueryClient()
+  const serverId = useOpenCodeServerId()
+  const queryKey = serverScopedKey(modelStateQueryKey(), serverId)
 
   return useMutation({
     mutationFn: fetcher,
     onMutate: async (input) => {
-      const queryKey = modelStateQueryKey()
       await queryClient.cancelQueries({ queryKey })
       const previousState = queryClient.getQueryData<OpenCodeModelState>(queryKey)
       if (previousState) queryClient.setQueryData(queryKey, applyOptimistic(previousState, input))
       return { previousState }
     },
     onSuccess: (state) => {
-      queryClient.setQueryData(modelStateQueryKey(), state)
+      queryClient.setQueryData(queryKey, state)
     },
     onError: (error, _input, context) => {
       if (context?.previousState) {
-        queryClient.setQueryData(modelStateQueryKey(), context.previousState)
+        queryClient.setQueryData(queryKey, context.previousState)
       }
       console.error(errorMessage, error)
     },
@@ -214,6 +221,8 @@ export function useModelSelection(
   session?: ModelSelectionSession,
 ): UseModelSelectionResult {
   const { data: catalog, isPlaceholderData: catalogIsPlaceholder } = useProviders(directory)
+  const serverId = useOpenCodeServerId()
+  const isLocalServer = isLocalOpenCodeServer(serverId)
 
   const activeAgent = useModelStore((state) => state.activeAgent)
   const newSessionPicks = useModelStore((state) => state.newSessionPicks)
@@ -222,13 +231,14 @@ export function useModelSelection(
   const setSessionPick = useModelStore((state) => state.setSessionPick)
   const setActiveAgent = useModelStore((state) => state.setActiveAgent)
 
-  const { data: modelState } = useOpenCodeModelState()
+  const { data: localModelState } = useOpenCodeModelState()
+  const modelState = isLocalServer ? localModelState : undefined
   const { data: configModelString } = useOpenCodeConfiguredModel(directory)
 
   const isModelReady = Boolean(
     catalog &&
       !catalogIsPlaceholder &&
-      modelState !== undefined &&
+      (!isLocalServer || modelState !== undefined) &&
       configModelString !== undefined,
   )
 
@@ -249,7 +259,7 @@ export function useModelSelection(
     [configModelString],
   )
 
-  const key = locationAgentKey(directory, activeAgent?.id)
+  const key = locationAgentKey(buildServerDirectoryKey(serverId, directory ?? ''), activeAgent?.id)
 
   const selection = useMemo(() => {
     if (!isModelReady || !catalog) return null
@@ -343,14 +353,16 @@ export function useModelSelection(
     } else {
       setNewSessionPick(key, nextModel)
     }
-    updateRecentModel.mutate(nextModel)
+    if (isLocalServer) updateRecentModel.mutate(nextModel)
   }
 
   const toggleFavorite = (nextModel: ModelSelection) => {
+    if (!isLocalServer) return
     updateFavoriteModel.mutate(nextModel)
   }
 
   const removeRecent = (nextModel: ModelSelection) => {
+    if (!isLocalServer) return
     removeRecentMutation.mutate(nextModel)
   }
 
diff --git a/frontend/src/hooks/useOpenCode.test.tsx b/frontend/src/hooks/useOpenCode.test.tsx
index 16741afe2..b9739e676 100644
--- a/frontend/src/hooks/useOpenCode.test.tsx
+++ b/frontend/src/hooks/useOpenCode.test.tsx
@@ -95,13 +95,13 @@ describe('useSessionsAcrossDirectories', () => {
       limit: 25,
       order: 'desc',
       search: undefined,
-    })
+    }, 'local')
     expect(mocks.listSessionPage).toHaveBeenCalledWith({
       directory: '/w/b',
       limit: 25,
       order: 'desc',
       search: undefined,
-    })
+    }, 'local')
 
     await act(async () => {
       await result.current.fetchNextPage()
@@ -111,7 +111,7 @@ describe('useSessionsAcrossDirectories', () => {
       expect(result.current.data).toHaveLength(3)
     })
 
-    expect(mocks.listSessionPage).toHaveBeenCalledWith({ directory: '/w/a', cursor: 'cursor_a' })
+    expect(mocks.listSessionPage).toHaveBeenCalledWith({ directory: '/w/a', cursor: 'cursor_a' }, 'local')
     expect(result.current.data.map((session) => session.id)).toEqual(['ses_a1', 'ses_b1', 'ses_a2'])
   })
 
@@ -130,7 +130,7 @@ describe('useSessionsAcrossDirectories', () => {
         limit: 25,
         order: 'desc',
         search: 'deploy',
-      })
+      }, 'local')
     })
   })
 
@@ -157,7 +157,7 @@ describe('useSessionsAcrossDirectories', () => {
       limit: 25,
       order: 'desc',
       search: undefined,
-    })
+    }, 'local')
     expect(result.current.data.map((session) => session.id)).toEqual(['ses_all1'])
     expect(result.current.hasNextPage).toBe(true)
 
@@ -170,7 +170,7 @@ describe('useSessionsAcrossDirectories', () => {
     })
 
     expect(mocks.listSessionPage).toHaveBeenCalledTimes(2)
-    expect(mocks.listSessionPage).toHaveBeenLastCalledWith({ cursor: 'cursor_all' })
+    expect(mocks.listSessionPage).toHaveBeenLastCalledWith({ cursor: 'cursor_all' }, 'local')
     expect(result.current.data.map((session) => session.id)).toEqual(['ses_all1', 'ses_all2'])
   })
 
@@ -193,7 +193,7 @@ describe('useSessionsAcrossDirectories', () => {
       order: 'desc',
       search: undefined,
       includeChildren: true,
-    })
+    }, 'local')
     expect(queryClient.getQueryCache().getAll()[0]?.queryKey).toEqual([
       'opencode',
       'sessions',
@@ -254,7 +254,7 @@ describe('useSessionsAcrossDirectories', () => {
       search: undefined,
       project: 'proj_x',
       subpath: '',
-    })
+    }, 'local')
     expect(result.current.data.map((session) => session.id)).toEqual(['ses_root'])
     expect(result.current.hasNextPage).toBe(true)
 
@@ -267,7 +267,7 @@ describe('useSessionsAcrossDirectories', () => {
     })
 
     expect(mocks.listSessionPage).toHaveBeenCalledTimes(2)
-    expect(mocks.listSessionPage).toHaveBeenLastCalledWith({ cursor: 'cursor_project' })
+    expect(mocks.listSessionPage).toHaveBeenLastCalledWith({ cursor: 'cursor_project' }, 'local')
     expect(result.current.data.map((session) => session.id)).toEqual(['ses_root', 'ses_wt'])
   })
 
@@ -292,7 +292,7 @@ describe('useSessionsAcrossDirectories', () => {
       await result.current.mutateAsync({ id: 'ses_a1', directory: '/w/a' })
     })
 
-    expect(mocks.deleteSession).toHaveBeenCalledWith('ses_a1')
+    expect(mocks.deleteSession).toHaveBeenCalledWith('ses_a1', 'local')
     const cached = queryClient.getQueryData<{ pages: Array<{ items: SessionInfo[] }> }>(listKey)
     expect(cached?.pages[0].items.map((session) => session.id)).toEqual(['ses_a2'])
     expect(queryClient.getQueryState(listKey)?.isInvalidated).toBe(false)
@@ -464,7 +464,7 @@ describe('useCreateSession', () => {
       await result.current.mutateAsync({ agent: undefined })
     })
 
-    expect(mocks.createSession).toHaveBeenCalledWith({ directory: '/w/a', agent: undefined })
+    expect(mocks.createSession).toHaveBeenCalledWith({ directory: '/w/a', agent: undefined }, 'local')
   })
 })
 
diff --git a/frontend/src/hooks/useOpenCode.ts b/frontend/src/hooks/useOpenCode.ts
index 87883e102..051dec618 100644
--- a/frontend/src/hooks/useOpenCode.ts
+++ b/frontend/src/hooks/useOpenCode.ts
@@ -20,6 +20,9 @@ import {
   type PromptSkillInput,
 } from "../api/opencode";
 import { FetchError } from "../api/fetchWrapper";
+import { LOCAL_OPENCODE_SERVER_ID } from "@opencode-manager/shared/schemas";
+import { useOpenCodeServerId } from "@/contexts/OpenCodeServerContext";
+import { serverScopedKey } from "@/lib/serverScope";
 import type { ModelRef, SessionInfo } from "@opencode-manager/shared/opencode";
 import { isSameModelRef } from "@opencode-manager/shared/opencode";
 import { parseNetworkError, isGatewayTimeout } from "../lib/opencode-errors";
@@ -45,6 +48,8 @@ interface UseSessionsAcrossDirectoriesOptions {
   allDirectories?: boolean
   project?: { id: string; subpath: string }
   includeChildren?: boolean
+  /** Overrides the route's server for callers that always read a specific server, such as local active work. */
+  serverId?: string
 }
 
 type SessionDirectoryCursors = Record<string, string>
@@ -62,6 +67,8 @@ export const useSessionsAcrossDirectories = (
   directories: string[],
   options?: UseSessionsAcrossDirectoriesOptions,
 ) => {
+  const routeServerId = useOpenCodeServerId();
+  const serverId = options?.serverId ?? routeServerId;
   const uniqueDirectories = useMemo(
     () => Array.from(new Set(directories.filter(Boolean))),
     [directories],
@@ -85,12 +92,12 @@ export const useSessionsAcrossDirectories = (
     readonly unknown[],
     SessionListPageParam | undefined
   >({
-    queryKey: [
+    queryKey: serverScopedKey([
       'opencode',
       'sessions',
       directoryKey,
       { search: normalizedSearch, limit, allDirectories, project: projectId, subpath: projectSubpath, includeChildren },
-    ],
+    ], serverId),
     queryFn: async ({ pageParam }) => {
       if (singleCursor) {
         const cursor = pageParam?.mode === 'all' ? pageParam.cursor : undefined;
@@ -104,6 +111,7 @@ export const useSessionsAcrossDirectories = (
                 ...childSessionsParam,
               }
             : { cursor, ...childSessionsParam },
+          serverId,
         );
         return {
           items: page.items,
@@ -114,13 +122,16 @@ export const useSessionsAcrossDirectories = (
       if (!pageParam || pageParam.mode !== 'directories') {
         const pages = await Promise.all(
           uniqueDirectories.map((directory) =>
-            listSessionPage({
-              directory,
-              limit,
-              order: 'desc',
-              search: normalizedSearch,
-              ...childSessionsParam,
-            }),
+            listSessionPage(
+              {
+                directory,
+                limit,
+                order: 'desc',
+                search: normalizedSearch,
+                ...childSessionsParam,
+              },
+              serverId,
+            ),
           ),
         );
         const cursors: SessionDirectoryCursors = {};
@@ -140,7 +151,7 @@ export const useSessionsAcrossDirectories = (
       const entries = Object.entries(pageParam.cursors);
       const pages = await Promise.all(
         entries.map(([directory, cursor]) =>
-          listSessionPage({ directory, cursor, ...childSessionsParam }),
+          listSessionPage({ directory, cursor, ...childSessionsParam }, serverId),
         ),
       );
       const cursors: SessionDirectoryCursors = {};
@@ -193,9 +204,13 @@ export const useSessionsAcrossDirectories = (
 const sessionQueryKey = (sessionID: string | undefined, directory?: string) =>
   ["opencode", "session", sessionID, directory] as const;
 
-export const sessionQueryOptions = (sessionID: string | undefined, directory?: string) => ({
-  queryKey: sessionQueryKey(sessionID, directory),
-  queryFn: () => getSession(sessionID!),
+export const sessionQueryOptions = (
+  sessionID: string | undefined,
+  directory?: string,
+  serverId: string = LOCAL_OPENCODE_SERVER_ID,
+) => ({
+  queryKey: serverScopedKey(sessionQueryKey(sessionID, directory), serverId),
+  queryFn: () => getSession(sessionID!, serverId),
   enabled: !!sessionID,
   refetchOnWindowFocus: true,
   refetchOnReconnect: true,
@@ -205,17 +220,19 @@ export const sessionQueryOptions = (sessionID: string | undefined, directory?: s
 });
 
 export const useSession = (sessionID: string | undefined, directory?: string) => {
-  return useQuery(sessionQueryOptions(sessionID, directory));
+  const serverId = useOpenCodeServerId();
+  return useQuery(sessionQueryOptions(sessionID, directory, serverId));
 };
 
 export const useChildSessionReconciliation = (sessionID: string | undefined) => {
+  const serverId = useOpenCodeServerId()
   const lifecycle = useChildLifecycleForSession(sessionID)
   useQuery({
-    queryKey: childSessionReconciliationQueryKey(sessionID),
+    queryKey: serverScopedKey(childSessionReconciliationQueryKey(sessionID), serverId),
     queryFn: async () => {
       const token = useSessionStatus.getState().beginStatusSnapshot();
       try {
-        const session = await getSession(sessionID!);
+        const session = await getSession(sessionID!, serverId);
         useSessionStatus.getState().applySessionSnapshot(sessionID!, session, token);
         return session;
       } finally {
@@ -233,6 +250,7 @@ export const useCreateSession = (
   directory?: string,
   onSuccess?: (session: { id: string }) => void,
 ) => {
+  const serverId = useOpenCodeServerId();
   const queryClient = useQueryClient();
 
   return useMutation({
@@ -246,7 +264,7 @@ export const useCreateSession = (
       if (!targetDirectory) {
         throw new Error('A directory is required to create a session');
       }
-      return createSession({ ...data, directory: targetDirectory });
+      return createSession({ ...data, directory: targetDirectory }, serverId);
     },
     onSuccess: (session) => {
       invalidateSessionListCaches(queryClient);
@@ -274,6 +292,7 @@ const getDeleteSessionTargetKey = (target: DeleteSessionTarget, fallbackDirector
   buildSessionKey(getDeleteSessionTargetDirectory(target, fallbackDirectory), getDeleteSessionTargetId(target));
 
 export const useDeleteSession = (directory?: string | string[]) => {
+  const serverId = useOpenCodeServerId();
   const queryClient = useQueryClient();
   const directories = useMemo(
     () => (Array.isArray(directory) ? directory : directory ? [directory] : []),
@@ -295,7 +314,7 @@ export const useDeleteSession = (directory?: string | string[]) => {
       const results: PromiseSettledResult<void>[] = []
       for (const target of targets) {
         try {
-          await deleteSession(getDeleteSessionTargetId(target))
+          await deleteSession(getDeleteSessionTargetId(target), serverId)
           results.push({ status: 'fulfilled', value: undefined })
         } catch (reason) {
           results.push({ status: 'rejected', reason })
@@ -369,15 +388,16 @@ const cleanupSessionPins = (
 };
 
 export const useUpdateSession = (directory?: string) => {
+  const serverId = useOpenCodeServerId();
   const queryClient = useQueryClient();
 
   return useMutation({
     mutationFn: async ({ sessionID, title }: { sessionID: string; title: string }) => {
-      return renameSession(sessionID, title);
+      return renameSession(sessionID, title, serverId);
     },
     onSuccess: (_, variables) => {
       const { sessionID } = variables;
-      queryClient.invalidateQueries({ queryKey: sessionQueryKey(sessionID, directory) });
+      queryClient.invalidateQueries({ queryKey: serverScopedKey(sessionQueryKey(sessionID, directory), serverId) });
       invalidateSessionListCaches(queryClient);
     },
   });
@@ -388,13 +408,15 @@ const patchCachedSessionSelection = (
   sessionID: string,
   directory: string | undefined,
   patch: Partial<Pick<SessionInfo, 'model' | 'agent'>>,
+  serverId?: string,
 ) => {
-  queryClient.setQueryData<SessionInfo>(sessionQueryKey(sessionID, directory), (current) =>
+  queryClient.setQueryData<SessionInfo>(serverScopedKey(sessionQueryKey(sessionID, directory), serverId), (current) =>
     current ? { ...current, ...patch } : current,
   );
 };
 
 export const useSyncSessionSelection = (directory?: string) => {
+  const serverId = useOpenCodeServerId();
   const queryClient = useQueryClient();
 
   return useCallback(
@@ -408,26 +430,27 @@ export const useSyncSessionSelection = (directory?: string) => {
       agent?: string;
     }) => {
       const session = queryClient.getQueryData<SessionInfo>(
-        sessionQueryKey(sessionID, directory),
+        serverScopedKey(sessionQueryKey(sessionID, directory), serverId),
       );
 
       let agentChanged = false;
       if (agent && agent !== session?.agent) {
-        await switchSessionAgent(sessionID, agent);
-        patchCachedSessionSelection(queryClient, sessionID, directory, { agent });
+        await switchSessionAgent(sessionID, agent, serverId);
+        patchCachedSessionSelection(queryClient, sessionID, directory, { agent }, serverId);
         agentChanged = true;
       }
 
       if (model && (agentChanged || !isSameModelRef(model, session?.model))) {
-        await switchSessionModel(sessionID, model);
-        patchCachedSessionSelection(queryClient, sessionID, directory, { model });
+        await switchSessionModel(sessionID, model, serverId);
+        patchCachedSessionSelection(queryClient, sessionID, directory, { model }, serverId);
       }
     },
-    [queryClient, directory],
+    [queryClient, directory, serverId],
   );
 };
 
 export const useSendPrompt = (directory?: string) => {
+  const serverId = useOpenCodeServerId();
   const queryClient = useQueryClient();
   const syncSelection = useSyncSessionSelection(directory);
 
@@ -455,10 +478,10 @@ export const useSendPrompt = (directory?: string) => {
 
       await syncSelection({ sessionID, model, agent });
 
-      const inbox = await sendPrompt({ sessionID, text, files, agents, skills, delivery });
+      const inbox = await sendPrompt({ sessionID, text, files, agents, skills, delivery }, serverId);
 
       queryClient.setQueryData<TranscriptCache>(
-        sessionTranscriptQueryKey(sessionID),
+        serverScopedKey(sessionTranscriptQueryKey(sessionID), serverId),
         (current) => {
           if (!current) return current;
           if (current.transcript.messages.some((message) => message.id === inbox.id)) {
@@ -497,8 +520,9 @@ export const useSendPrompt = (directory?: string) => {
 };
 
 export const useBackgroundSession = () => {
+  const serverId = useOpenCodeServerId();
   return useMutation({
-    mutationFn: (sessionID: string) => backgroundSession(sessionID),
+    mutationFn: (sessionID: string) => backgroundSession(sessionID, serverId),
     onError: (error) => {
       showToast.error(error instanceof Error ? error.message : "Failed to move work to the background");
     },
@@ -509,6 +533,7 @@ const ABORT_RETRY_INTERVAL_MS = 3000;
 const MAX_ABORT_RETRIES = 10;
 
 export const useInterruptSession = () => {
+  const serverId = useOpenCodeServerId();
   const retryIntervalRef = useRef<ReturnType<typeof setInterval> | null>(null);
   const retryCountRef = useRef(0);
 
@@ -530,7 +555,7 @@ export const useInterruptSession = () => {
 
       const attemptAbort = async () => {
         try {
-          await interruptSession(targetSessionID);
+          await interruptSession(targetSessionID, serverId);
           stopRetrying();
         } catch {
           // Will retry on next interval
@@ -563,6 +588,7 @@ export const useInterruptSession = () => {
 };
 
 export const useSendShell = (directory?: string) => {
+  const serverId = useOpenCodeServerId();
   const queryClient = useQueryClient();
 
   return useMutation({
@@ -573,40 +599,43 @@ export const useSendShell = (directory?: string) => {
       sessionID: string;
       command: string;
     }) => {
-      return runShell(sessionID, command);
+      return runShell(sessionID, command, serverId);
     },
     onSuccess: (_data, variables) => {
       const { sessionID } = variables;
 
       queryClient.invalidateQueries({
-        queryKey: sessionQueryKey(sessionID, directory),
+        queryKey: serverScopedKey(sessionQueryKey(sessionID, directory), serverId),
       });
     },
   });
 };
 
 export const useAgents = (directory?: string, options?: { enabled?: boolean }) => {
+  const serverId = useOpenCodeServerId();
   return useQuery({
-    queryKey: ["opencode", "agents", directory],
-    queryFn: () => listAgents(directory),
+    queryKey: serverScopedKey(["opencode", "agents", directory], serverId),
+    queryFn: () => listAgents(directory, serverId),
     enabled: options?.enabled ?? true,
   });
 };
 
 export const useSkills = (directory?: string, options?: { enabled?: boolean }) => {
+  const serverId = useOpenCodeServerId();
   return useQuery({
-    queryKey: ["opencode", "skills", directory],
-    queryFn: () => listSkills(directory),
+    queryKey: serverScopedKey(["opencode", "skills", directory], serverId),
+    queryFn: () => listSkills(directory, serverId),
     enabled: options?.enabled ?? true,
   });
 };
 
 export const useLoadSkill = (sessionID: string | undefined) => {
+  const serverId = useOpenCodeServerId();
   return useMutation<void, Error, { skillName: string }>({
     mutationFn: async ({ skillName }: { skillName: string }) => {
       if (!sessionID) throw new Error("No active session");
 
-      return activateSkill(sessionID, skillName);
+      return activateSkill(sessionID, skillName, serverId);
     },
     onError: (error) => {
       showToast.error(error instanceof Error ? error.message : "Failed to load skill");
diff --git a/frontend/src/hooks/useOpenCodeServers.ts b/frontend/src/hooks/useOpenCodeServers.ts
new file mode 100644
index 000000000..b0da8cd78
--- /dev/null
+++ b/frontend/src/hooks/useOpenCodeServers.ts
@@ -0,0 +1,98 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
+import type {
+  CreateOpenCodeServerRequest,
+  OpenCodeServerStatus,
+  TestOpenCodeServerRequest,
+  UpdateOpenCodeServerRequest,
+} from '@opencode-manager/shared/schemas'
+import {
+  createOpenCodeServer,
+  deleteOpenCodeServer,
+  listOpenCodeServers,
+  listOpenCodeServerStatuses,
+  testOpenCodeServer,
+  testOpenCodeServerById,
+  updateOpenCodeServer,
+} from '@/api/opencodeServers'
+
+const OPENCODE_SERVERS_QUERY_KEY = ['opencode-servers']
+const OPENCODE_SERVER_STATUSES_QUERY_KEY = ['opencode-server-statuses']
+const SERVER_STATUS_POLL_INTERVAL_MS = 15000
+
+export function useOpenCodeServers(options: { enabled?: boolean } = {}) {
+  const queryClient = useQueryClient()
+  const serversQuery = useQuery({
+    queryKey: OPENCODE_SERVERS_QUERY_KEY,
+    queryFn: listOpenCodeServers,
+    enabled: options.enabled ?? true,
+  })
+
+  const invalidateServers = () => {
+    queryClient.invalidateQueries({ queryKey: OPENCODE_SERVERS_QUERY_KEY })
+  }
+
+  const createMutation = useMutation({
+    mutationFn: (input: CreateOpenCodeServerRequest) => createOpenCodeServer(input),
+    onSuccess: invalidateServers,
+  })
+
+  const updateMutation = useMutation({
+    mutationFn: ({ id, input }: { id: string; input: UpdateOpenCodeServerRequest }) =>
+      updateOpenCodeServer(id, input),
+    onSuccess: invalidateServers,
+  })
+
+  const deleteMutation = useMutation({
+    mutationFn: (id: string) => deleteOpenCodeServer(id),
+    onSuccess: invalidateServers,
+  })
+
+  const testMutation = useMutation({
+    mutationFn: (input: TestOpenCodeServerRequest) => testOpenCodeServer(input),
+  })
+
+  const testByIdMutation = useMutation({
+    mutationFn: (id: string) => testOpenCodeServerById(id),
+  })
+
+  return {
+    servers: serversQuery.data ?? [],
+    isLoading: serversQuery.isLoading,
+    error: serversQuery.error,
+    refetch: serversQuery.refetch,
+    createAsync: createMutation.mutateAsync,
+    isCreating: createMutation.isPending,
+    updateAsync: updateMutation.mutateAsync,
+    isUpdating: updateMutation.isPending,
+    deleteAsync: deleteMutation.mutateAsync,
+    isDeleting: deleteMutation.isPending,
+    testAsync: testMutation.mutateAsync,
+    testByIdAsync: testByIdMutation.mutateAsync,
+  }
+}
+
+export function useOpenCodeServerStatuses(options: { enabled?: boolean } = {}) {
+  const statusesQuery = useQuery({
+    queryKey: OPENCODE_SERVER_STATUSES_QUERY_KEY,
+    queryFn: listOpenCodeServerStatuses,
+    refetchInterval: SERVER_STATUS_POLL_INTERVAL_MS,
+    retry: false,
+    enabled: options.enabled ?? true,
+  })
+
+  const statusById = (statusesQuery.data ?? []).reduce<Record<string, OpenCodeServerStatus>>(
+    (byId, status) => {
+      byId[status.serverId] = status
+      return byId
+    },
+    {},
+  )
+
+  return {
+    statuses: statusesQuery.data ?? [],
+    statusById,
+    isLoading: statusesQuery.isLoading,
+    error: statusesQuery.error,
+    refetch: statusesQuery.refetch,
+  }
+}
diff --git a/frontend/src/hooks/usePermissionModeToggle.ts b/frontend/src/hooks/usePermissionModeToggle.ts
index 2f048edec..0effe79a4 100644
--- a/frontend/src/hooks/usePermissionModeToggle.ts
+++ b/frontend/src/hooks/usePermissionModeToggle.ts
@@ -1,7 +1,11 @@
 import { useSessionPermissionMode, useSetSessionPermissionMode } from '@/hooks/useSessionPermissionMode'
 
-export function usePermissionModeToggle(sessionID: string, directory: string) {
-  const { data, isError } = useSessionPermissionMode(sessionID)
+export function usePermissionModeToggle(
+  sessionID: string,
+  directory: string,
+  options: { enabled?: boolean } = {},
+) {
+  const { data, isError } = useSessionPermissionMode(sessionID, options)
   const setMode = useSetSessionPermissionMode(sessionID)
 
   const loaded = data !== undefined
diff --git a/frontend/src/hooks/useProviders.ts b/frontend/src/hooks/useProviders.ts
index 24d10a773..c5f77e178 100644
--- a/frontend/src/hooks/useProviders.ts
+++ b/frontend/src/hooks/useProviders.ts
@@ -1,14 +1,18 @@
 import { keepPreviousData, useQuery } from '@tanstack/react-query'
 import { getProviders } from '@/api/providers'
+import { useOpenCodeServerId } from '@/contexts/OpenCodeServerContext'
+import { serverScopedKey } from '@/lib/serverScope'
 
 interface UseProvidersOptions {
   enabled?: boolean
 }
 
 export function useProviders(directory?: string, options: UseProvidersOptions = {}) {
+  const serverId = useOpenCodeServerId()
+
   return useQuery({
-    queryKey: ['opencode', 'providers', directory],
-    queryFn: () => getProviders(directory),
+    queryKey: serverScopedKey(['opencode', 'providers', directory], serverId),
+    queryFn: () => getProviders(directory, serverId),
     enabled: options.enabled ?? true,
     staleTime: 30000,
     placeholderData: keepPreviousData,
diff --git a/frontend/src/hooks/useRemoveMessage.test.ts b/frontend/src/hooks/useRemoveMessage.test.ts
index a4fdad42f..1b9249486 100644
--- a/frontend/src/hooks/useRemoveMessage.test.ts
+++ b/frontend/src/hooks/useRemoveMessage.test.ts
@@ -80,12 +80,12 @@ describe('useRefreshMessage', () => {
       agent: 'build',
     })
 
-    expect(mocks.stageRevert).toHaveBeenCalledWith('test-session', 'assistant-1')
-    expect(mocks.commitRevert).toHaveBeenCalledWith('test-session')
+    expect(mocks.stageRevert).toHaveBeenCalledWith('test-session', 'assistant-1', 'local')
+    expect(mocks.commitRevert).toHaveBeenCalledWith('test-session', 'local')
     expect(mocks.sendPrompt).toHaveBeenCalledWith({
       sessionID: 'test-session',
       text: 'edited text',
-    })
+    }, 'local')
     expect(mocks.switchSessionModel).not.toHaveBeenCalled()
     expect(mocks.switchSessionAgent).not.toHaveBeenCalled()
   })
@@ -123,7 +123,7 @@ describe('useRefreshMessage', () => {
     expect(mocks.switchSessionModel).toHaveBeenCalledWith('test-session', {
       providerID: 'openai',
       id: 'gpt-4',
-    })
+    }, 'local')
     expect(mocks.switchSessionAgent).not.toHaveBeenCalled()
     expect(mocks.switchSessionModel.mock.invocationCallOrder[0]).toBeLessThan(
       mocks.sendPrompt.mock.invocationCallOrder[0],
@@ -142,11 +142,11 @@ describe('useRefreshMessage', () => {
       agent: 'plan',
     })
 
-    expect(mocks.switchSessionAgent).toHaveBeenCalledWith('test-session', 'plan')
+    expect(mocks.switchSessionAgent).toHaveBeenCalledWith('test-session', 'plan', 'local')
     expect(mocks.switchSessionModel).toHaveBeenCalledWith('test-session', {
       providerID: 'anthropic',
       id: 'claude-sonnet-4',
-    })
+    }, 'local')
     expect(mocks.switchSessionAgent.mock.invocationCallOrder[0]).toBeLessThan(
       mocks.switchSessionModel.mock.invocationCallOrder[0],
     )
diff --git a/frontend/src/hooks/useRemoveMessage.ts b/frontend/src/hooks/useRemoveMessage.ts
index 957d4d880..93361831d 100644
--- a/frontend/src/hooks/useRemoveMessage.ts
+++ b/frontend/src/hooks/useRemoveMessage.ts
@@ -5,6 +5,7 @@ import {
   stageRevert,
 } from '@/api/opencode'
 import { parseOpenCodeModelRef } from '@opencode-manager/shared/opencode'
+import { useOpenCodeServerId } from '@/contexts/OpenCodeServerContext'
 import { useSyncSessionSelection } from '@/hooks/useOpenCode'
 import { showToast } from '@/lib/toast'
 import { sessionTranscriptQueryKey } from '@/lib/queryInvalidation'
@@ -16,11 +17,12 @@ interface UseRemoveMessageOptions {
 
 export function useRemoveMessage({ sessionId, directory }: UseRemoveMessageOptions) {
   const queryClient = useQueryClient()
+  const serverId = useOpenCodeServerId()
 
   return useMutation({
     mutationFn: async ({ messageID }: { messageID: string }) => {
-      await stageRevert(sessionId, messageID)
-      await commitRevert(sessionId)
+      await stageRevert(sessionId, messageID, serverId)
+      await commitRevert(sessionId, serverId)
     },
     onError: () => {
       showToast.error('Failed to remove message')
@@ -41,6 +43,7 @@ interface UseRefreshMessageOptions {
 
 export function useRefreshMessage({ sessionId, directory }: UseRefreshMessageOptions) {
   const queryClient = useQueryClient()
+  const serverId = useOpenCodeServerId()
   const removeMessage = useRemoveMessage({ sessionId, directory })
   const syncSelection = useSyncSessionSelection(directory)
 
@@ -61,10 +64,13 @@ export function useRefreshMessage({ sessionId, directory }: UseRefreshMessageOpt
       const modelRef = model ? parseOpenCodeModelRef(model) : undefined
       await syncSelection({ sessionID: sessionId, model: modelRef, agent })
 
-      await sendPrompt({
-        sessionID: sessionId,
-        text: userMessageContent,
-      })
+      await sendPrompt(
+        {
+          sessionID: sessionId,
+          text: userMessageContent,
+        },
+        serverId,
+      )
 
       return { userMessageContent }
     },
diff --git a/frontend/src/hooks/useResolveConflictsWithAgent.test.tsx b/frontend/src/hooks/useResolveConflictsWithAgent.test.tsx
index 1ed30e6c9..4ad4bd349 100644
--- a/frontend/src/hooks/useResolveConflictsWithAgent.test.tsx
+++ b/frontend/src/hooks/useResolveConflictsWithAgent.test.tsx
@@ -76,6 +76,7 @@ describe('useResolveConflictsWithAgent', () => {
         title: 'Resolve rebase conflicts',
       },
       expect.stringContaining('GIT_EDITOR=true git rebase --continue'),
+      'local',
     )
     await waitFor(() => expect(locationRef.current).toBe('/repos/1/sessions/ses_new'))
   })
diff --git a/frontend/src/hooks/useResolveConflictsWithAgent.ts b/frontend/src/hooks/useResolveConflictsWithAgent.ts
index 5e53a6bf7..49f1b1492 100644
--- a/frontend/src/hooks/useResolveConflictsWithAgent.ts
+++ b/frontend/src/hooks/useResolveConflictsWithAgent.ts
@@ -1,6 +1,7 @@
 import { useMutation, useQueryClient } from '@tanstack/react-query'
 import { useNavigate } from 'react-router-dom'
 import { createSessionWithPrompt } from '@/api/opencode'
+import { useOpenCodeServerId } from '@/contexts/OpenCodeServerContext'
 import { buildConflictResolutionPrompt } from '@/lib/git-conflict-prompt'
 import { getSessionPath } from '@/lib/navigation'
 import { invalidateSessionListCaches } from '@/lib/queryInvalidation'
@@ -18,6 +19,7 @@ interface ResolveConflictsRepo {
 }
 
 export function useResolveConflictsWithAgent(repo: ResolveConflictsRepo) {
+  const serverId = useOpenCodeServerId()
   const queryClient = useQueryClient()
   const navigate = useNavigate()
 
@@ -29,6 +31,7 @@ export function useResolveConflictsWithAgent(repo: ResolveConflictsRepo) {
           title: `Resolve ${operation.kind} conflicts`,
         },
         buildConflictResolutionPrompt({ operation, branch }),
+        serverId,
       )
     },
     onSuccess: (session) => {
diff --git a/frontend/src/hooks/useSSE.test.tsx b/frontend/src/hooks/useSSE.test.tsx
index 1a94d6055..5454cd58b 100644
--- a/frontend/src/hooks/useSSE.test.tsx
+++ b/frontend/src/hooks/useSSE.test.tsx
@@ -4,6 +4,7 @@ import type { ReactNode } from 'react'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { useSSE } from './useSSE'
 import { useKillShell } from './useSessionShells'
+import { OpenCodeServerProvider } from '@/contexts/OpenCodeServerContext'
 import { clearShellExitRecord } from '@/lib/backgroundWork'
 import { useSessionStatus } from '../stores/sessionStatusStore'
 import { useSendErrorStore } from '../stores/sendErrorStore'
@@ -412,6 +413,62 @@ describe('useSSE', () => {
     unmount()
   })
 
+  it('ignores a remote resync while the browser stream stays connected', async () => {
+    const queryClient = new QueryClient({
+      defaultOptions: {
+        queries: { retry: false },
+      },
+    })
+    const invalidateQueries = vi.spyOn(queryClient, 'invalidateQueries')
+
+    const { result, unmount } = renderHook(
+      () => useSSE('/repo', 'session-1'),
+      { wrapper: createWrapper(queryClient) }
+    )
+
+    await waitFor(() => expect(MockEventSource.instances).toHaveLength(1))
+    await connect(0, 'client-1')
+    await waitFor(() => expect(result.current.isConnected).toBe(true))
+    invalidateQueries.mockClear()
+
+    act(() => {
+      MockEventSource.instances[0].emit('resync', { timestamp: Date.now(), serverId: 'srv_remote' })
+    })
+
+    expect(invalidateQueries).not.toHaveBeenCalled()
+
+    unmount()
+  })
+
+  it('ignores a local resync on a remote server', async () => {
+    const queryClient = new QueryClient({
+      defaultOptions: {
+        queries: { retry: false },
+      },
+    })
+    const wrapper = ({ children }: { children: ReactNode }) => (
+      <QueryClientProvider client={queryClient}>
+        <OpenCodeServerProvider serverId="srv_remote">{children}</OpenCodeServerProvider>
+      </QueryClientProvider>
+    )
+    const invalidateQueries = vi.spyOn(queryClient, 'invalidateQueries')
+
+    const { result, unmount } = renderHook(() => useSSE('/repo', 'session-1'), { wrapper })
+
+    await waitFor(() => expect(MockEventSource.instances).toHaveLength(1))
+    await connect(0, 'client-1')
+    await waitFor(() => expect(result.current.isConnected).toBe(true))
+    invalidateQueries.mockClear()
+
+    act(() => {
+      MockEventSource.instances[0].emit('resync', { timestamp: Date.now() })
+    })
+
+    expect(invalidateQueries).not.toHaveBeenCalled()
+
+    unmount()
+  })
+
   it('tracks background shells from shell lifecycle events without dropping completed shells', async () => {
     const queryClient = new QueryClient({
       defaultOptions: {
@@ -843,4 +900,76 @@ describe('useSSE', () => {
 
     unmount()
   })
+
+  it('ignores events belonging to another OpenCode server', async () => {
+    const queryClient = new QueryClient({
+      defaultOptions: {
+        queries: { retry: false },
+      },
+    })
+    const invalidateQueries = vi.spyOn(queryClient, 'invalidateQueries')
+    queryClient.setQueryData(['opencode', 'session', 'session-2', '/repo'], { id: 'session-2' })
+
+    const { result, unmount } = renderHook(
+      () => useSSE('/repo', 'session-1'),
+      { wrapper: createWrapper(queryClient) }
+    )
+
+    await waitFor(() => expect(MockEventSource.instances).toHaveLength(1))
+    await connect(0, 'client-1')
+    await waitFor(() => expect(result.current.isConnected).toBe(true))
+    invalidateQueries.mockClear()
+
+    act(() => {
+      MockEventSource.instances[0].emit('message', {
+        type: 'session.created',
+        serverId: 'srv_remote',
+        directory: '/repo',
+        data: { sessionID: 'session-2', projectID: 'proj-1', slug: 'slug', location: { directory: '/repo' } },
+      })
+    })
+
+    expect(invalidateQueries).not.toHaveBeenCalledWith({ queryKey: ['opencode', 'session', 'session-2'] })
+
+    act(() => {
+      MockEventSource.instances[0].emit('message', {
+        type: 'session.created',
+        directory: '/repo',
+        data: { sessionID: 'session-2', projectID: 'proj-1', slug: 'slug', location: { directory: '/repo' } },
+      })
+    })
+
+    await waitFor(() => {
+      expect(invalidateQueries).toHaveBeenCalledWith({ queryKey: ['opencode', 'session', 'session-2'] })
+    })
+
+    unmount()
+  })
+
+  it('subscribes with the server-scoped directory key for a remote server', async () => {
+    const queryClient = new QueryClient({
+      defaultOptions: {
+        queries: { retry: false },
+      },
+    })
+
+    const wrapper = ({ children }: { children: ReactNode }) => (
+      <QueryClientProvider client={queryClient}>
+        <OpenCodeServerProvider serverId="srv_remote">{children}</OpenCodeServerProvider>
+      </QueryClientProvider>
+    )
+
+    const { unmount } = renderHook(() => useSSE('/repo', 'session-1'), { wrapper })
+
+    await waitFor(() => expect(MockEventSource.instances).toHaveLength(1))
+    await connect(0, 'client-1')
+
+    await waitFor(() => {
+      expect(globalThis.fetch).toHaveBeenCalledWith('/api/sse/subscribe', expect.objectContaining({
+        body: JSON.stringify({ clientId: 'client-1', directories: ['srv_remote|/repo'] }),
+      }))
+    })
+
+    unmount()
+  })
 })
diff --git a/frontend/src/hooks/useSSE.ts b/frontend/src/hooks/useSSE.ts
index 2448b4635..23e60ad20 100644
--- a/frontend/src/hooks/useSSE.ts
+++ b/frontend/src/hooks/useSSE.ts
@@ -1,5 +1,6 @@
 import { useEffect, useRef, useState, useCallback, useMemo } from 'react'
 import { useQueryClient } from '@tanstack/react-query'
+import { buildServerDirectoryKey, LOCAL_OPENCODE_SERVER_ID } from '@opencode-manager/shared/schemas'
 import type { SessionInfo, V2Event } from '@opencode-manager/shared/opencode'
 import { invalidateSessionListCaches, invalidateShellCaches, shellsQueryKey } from '@/lib/queryInvalidation'
 import {
@@ -14,8 +15,10 @@ import { showToast } from '@/lib/toast'
 import { useSendErrorStore } from '@/stores/sendErrorStore'
 import { openCodeEventStream } from '@/lib/opencode-event-stream'
 import type { EventStreamSubscription } from '@/lib/opencode-event-stream'
+import { serverScopedKey } from '@/lib/serverScope'
+import { useOpenCodeServerId } from '@/contexts/OpenCodeServerContext'
 
-type V2StreamEvent = V2Event & { directory?: string }
+type V2StreamEvent = V2Event & { directory?: string; serverId?: string }
 
 const getEventDirectory = (event: V2StreamEvent): string | undefined => {
   return typeof event.directory === 'string' ? event.directory : undefined
@@ -43,6 +46,7 @@ const patchSessionIfCached = (
 }
 
 export const useSSE = (directory?: string | string[], currentSessionId?: string) => {
+  const serverId = useOpenCodeServerId()
   const directoriesList = useMemo(() => {
     if (!directory) return [] as string[]
     if (Array.isArray(directory)) return directory.filter(Boolean)
@@ -70,6 +74,7 @@ export const useSSE = (directory?: string | string[], currentSessionId?: string)
   )
 
   const handleSSEEvent = useCallback((event: V2StreamEvent) => {
+    if ((event.serverId ?? LOCAL_OPENCODE_SERVER_ID) !== serverId) return
     const eventDirectory = getEventDirectory(event)
     const cacheDirectory = resolveCacheDirectory(eventDirectory)
     if (eventDirectory && directorySet.size > 0 && cacheDirectory !== eventDirectory) return
@@ -117,7 +122,7 @@ export const useSSE = (directory?: string | string[], currentSessionId?: string)
 
       case 'shell.created': {
         const info = event.data.info
-        const key = shellsQueryKey(cacheDirectory)
+        const key = serverScopedKey(shellsQueryKey(cacheDirectory), serverId)
         const current = queryClient.getQueryData<ShellRecord[]>(key)
         if (!current) {
           queryClient.invalidateQueries({ queryKey: key })
@@ -129,7 +134,7 @@ export const useSSE = (directory?: string | string[], currentSessionId?: string)
 
       case 'shell.exited': {
         recordShellExit(cacheDirectory ?? '', event.data)
-        const key = shellsQueryKey(cacheDirectory)
+        const key = serverScopedKey(shellsQueryKey(cacheDirectory), serverId)
         const current = queryClient.getQueryData<ShellRecord[]>(key)
         if (!current || !current.some((shell) => shell.id === event.data.id)) {
           queryClient.invalidateQueries({ queryKey: key })
@@ -141,7 +146,7 @@ export const useSSE = (directory?: string | string[], currentSessionId?: string)
 
       case 'shell.deleted': {
         recordShellDeleted(cacheDirectory ?? '', event.data.id)
-        const key = shellsQueryKey(cacheDirectory)
+        const key = serverScopedKey(shellsQueryKey(cacheDirectory), serverId)
         const current = queryClient.getQueryData<ShellRecord[]>(key)
         if (!current || !current.some((shell) => shell.id === event.data.id)) break
         queryClient.setQueryData<ShellRecord[]>(key, (shells) => markShellDeleted(shells ?? [], event.data.id))
@@ -158,7 +163,7 @@ export const useSSE = (directory?: string | string[], currentSessionId?: string)
       default:
         break
     }
-  }, [queryClient, directorySet, resolveCacheDirectory])
+  }, [queryClient, directorySet, resolveCacheDirectory, serverId])
 
   const refreshCurrentSession = useCallback(() => {
     const sessionId = sessionIdRef.current
@@ -209,15 +214,16 @@ export const useSSE = (directory?: string | string[], currentSessionId?: string)
       }
     }
 
-    const handleResync = () => {
+    const handleResync = (_subscribedDirectories: string[], resyncServerId?: string) => {
       if (!mountedRef.current) return
+      if ((resyncServerId ?? LOCAL_OPENCODE_SERVER_ID) !== serverId) return
       invalidateSessionListCaches(queryClient)
       invalidateShellCaches(queryClient)
       refreshCurrentSession()
     }
 
     const subscription = openCodeEventStream.subscribeGlobalMonitor({
-      directories: directoriesList,
+      directories: directoriesList.map((entry) => buildServerDirectoryKey(serverId, entry)),
       onEvent: handleMessage,
       onStatusChange: handleStatusChange,
       onResync: handleResync,
@@ -247,7 +253,7 @@ export const useSSE = (directory?: string | string[], currentSessionId?: string)
         eventStreamSubscriptionRef.current = null
       }
     }
-  }, [directoryKey, directoriesList, handleSSEEvent, syncCurrentSession, refreshCurrentSession, queryClient])
+  }, [directoryKey, directoriesList, handleSSEEvent, syncCurrentSession, refreshCurrentSession, queryClient, serverId])
 
   useEffect(() => {
     if (isConnected && document.visibilityState === 'visible') {
diff --git a/frontend/src/hooks/useSandboxToggle.ts b/frontend/src/hooks/useSandboxToggle.ts
index c3a577aac..16a8906ad 100644
--- a/frontend/src/hooks/useSandboxToggle.ts
+++ b/frontend/src/hooks/useSandboxToggle.ts
@@ -1,7 +1,7 @@
 import { useSessionSandbox, useSetSessionSandbox } from '@/hooks/useSessionSandbox'
 
-export function useSandboxToggle(sessionID: string) {
-  const { data, isError } = useSessionSandbox(sessionID)
+export function useSandboxToggle(sessionID: string, options: { enabled?: boolean } = {}) {
+  const { data, isError } = useSessionSandbox(sessionID, options)
   const setSandbox = useSetSessionSandbox(sessionID)
 
   const loaded = data !== undefined
diff --git a/frontend/src/hooks/useSendPrompt.test.ts b/frontend/src/hooks/useSendPrompt.test.ts
index 9545cd7c8..f31e7bd03 100644
--- a/frontend/src/hooks/useSendPrompt.test.ts
+++ b/frontend/src/hooks/useSendPrompt.test.ts
@@ -129,7 +129,7 @@ describe('useSendPrompt', () => {
       agents: undefined,
       skills: undefined,
       delivery: undefined,
-    })
+    }, 'local')
   })
 
   it('switches the model before prompting when the selection changed', async () => {
@@ -151,7 +151,7 @@ describe('useSendPrompt', () => {
       providerID: 'openai',
       id: 'gpt-4',
       variant: 'v1',
-    })
+    }, 'local')
     expect(mocks.switchSessionModel.mock.invocationCallOrder[0]).toBeLessThan(
       mocks.sendPrompt.mock.invocationCallOrder[0],
     )
@@ -173,11 +173,11 @@ describe('useSendPrompt', () => {
       agent: 'plan',
     })
 
-    expect(mocks.switchSessionAgent).toHaveBeenCalledWith('test-session', 'plan')
+    expect(mocks.switchSessionAgent).toHaveBeenCalledWith('test-session', 'plan', 'local')
     expect(mocks.switchSessionModel).toHaveBeenCalledWith('test-session', {
       providerID: 'anthropic',
       id: 'claude-sonnet-4',
-    })
+    }, 'local')
     expect(mocks.switchSessionAgent.mock.invocationCallOrder[0]).toBeLessThan(
       mocks.switchSessionModel.mock.invocationCallOrder[0],
     )
@@ -198,8 +198,8 @@ describe('useSendPrompt', () => {
       agent: 'plan',
     })
 
-    expect(mocks.switchSessionAgent).toHaveBeenCalledWith('test-session', 'plan')
-    expect(mocks.switchSessionModel).toHaveBeenCalledWith('test-session', { providerID: 'openai', id: 'gpt-4' })
+    expect(mocks.switchSessionAgent).toHaveBeenCalledWith('test-session', 'plan', 'local')
+    expect(mocks.switchSessionModel).toHaveBeenCalledWith('test-session', { providerID: 'openai', id: 'gpt-4' }, 'local')
     expect(mocks.switchSessionAgent.mock.invocationCallOrder[0]).toBeLessThan(
       mocks.switchSessionModel.mock.invocationCallOrder[0],
     )
@@ -216,8 +216,8 @@ describe('useSendPrompt', () => {
     await result.current.mutateAsync({ sessionID: 'test-session', text: 'second', model: modelA })
 
     expect(mocks.switchSessionModel.mock.calls).toEqual([
-      ['test-session', modelB],
-      ['test-session', modelA],
+      ['test-session', modelB, 'local'],
+      ['test-session', modelA, 'local'],
     ])
   })
 
@@ -230,8 +230,8 @@ describe('useSendPrompt', () => {
     await result.current.mutateAsync({ sessionID: 'test-session', text: 'second', agent: 'build' })
 
     expect(mocks.switchSessionAgent.mock.calls).toEqual([
-      ['test-session', 'plan'],
-      ['test-session', 'build'],
+      ['test-session', 'plan', 'local'],
+      ['test-session', 'build', 'local'],
     ])
   })
 
diff --git a/frontend/src/hooks/useSessionGoals.ts b/frontend/src/hooks/useSessionGoals.ts
index 3122e6bf5..8a2a774b1 100644
--- a/frontend/src/hooks/useSessionGoals.ts
+++ b/frontend/src/hooks/useSessionGoals.ts
@@ -13,10 +13,11 @@ function sessionGoalQueryKey(sessionId: string) {
   return ['session-goal', sessionId] as const
 }
 
-export function useSessionGoal(sessionId: string) {
+export function useSessionGoal(sessionId: string, options: { enabled?: boolean } = {}) {
   return useQuery({
     queryKey: sessionGoalQueryKey(sessionId),
     queryFn: () => getLatestSessionGoal(sessionId),
+    enabled: options.enabled ?? true,
     refetchInterval: (query) => (query.state.data?.status === 'active' ? SESSION_GOAL_POLL_INTERVAL_MS : false),
   })
 }
diff --git a/frontend/src/hooks/useSessionPermissionMode.ts b/frontend/src/hooks/useSessionPermissionMode.ts
index 7565e39b7..6f49862a9 100644
--- a/frontend/src/hooks/useSessionPermissionMode.ts
+++ b/frontend/src/hooks/useSessionPermissionMode.ts
@@ -7,10 +7,11 @@ function sessionPermissionModeQueryKey(sessionId: string) {
   return ['session-permission-mode', sessionId] as const
 }
 
-export function useSessionPermissionMode(sessionId: string) {
+export function useSessionPermissionMode(sessionId: string, options: { enabled?: boolean } = {}) {
   return useQuery({
     queryKey: sessionPermissionModeQueryKey(sessionId),
     queryFn: () => getSessionPermissionMode(sessionId),
+    enabled: options.enabled ?? true,
     staleTime: 30000,
   })
 }
diff --git a/frontend/src/hooks/useSessionSandbox.ts b/frontend/src/hooks/useSessionSandbox.ts
index cb285a359..d9892568f 100644
--- a/frontend/src/hooks/useSessionSandbox.ts
+++ b/frontend/src/hooks/useSessionSandbox.ts
@@ -8,10 +8,11 @@ function sessionSandboxQueryKey(sessionId: string) {
   return ['session-sandbox', sessionId] as const
 }
 
-export function useSessionSandbox(sessionId: string) {
+export function useSessionSandbox(sessionId: string, options: { enabled?: boolean } = {}) {
   return useQuery({
     queryKey: sessionSandboxQueryKey(sessionId),
     queryFn: () => getSessionSandbox(sessionId),
+    enabled: options.enabled ?? true,
     staleTime: 30000,
   })
 }
diff --git a/frontend/src/hooks/useSessionShells.ts b/frontend/src/hooks/useSessionShells.ts
index a5da4979f..b974a5379 100644
--- a/frontend/src/hooks/useSessionShells.ts
+++ b/frontend/src/hooks/useSessionShells.ts
@@ -3,6 +3,8 @@ import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
 import { listShells, removeShell } from '@/api/opencode'
 import { applyShellExit, recordShellExit, reconcileShellList, type ShellRecord } from '@/lib/backgroundWork'
 import { shellsQueryKey } from '@/lib/queryInvalidation'
+import { serverScopedKey } from '@/lib/serverScope'
+import { useOpenCodeServerId } from '@/contexts/OpenCodeServerContext'
 import { showToast } from '@/lib/toast'
 
 function useShellListQuery<TData = ShellRecord[]>(
@@ -10,14 +12,16 @@ function useShellListQuery<TData = ShellRecord[]>(
   enabled: boolean,
   select?: (shells: ShellRecord[]) => TData,
 ) {
+  const serverId = useOpenCodeServerId()
   const queryClient = useQueryClient()
+  const queryKey = serverScopedKey(shellsQueryKey(directory), serverId)
 
   return useQuery<ShellRecord[], Error, TData>({
-    queryKey: shellsQueryKey(directory),
+    queryKey,
     queryFn: async (): Promise<ShellRecord[]> => {
       const fetchStartedAt = Date.now()
-      const fetched = await listShells(directory ?? '')
-      const existing = queryClient.getQueryData<ShellRecord[]>(shellsQueryKey(directory)) ?? []
+      const fetched = await listShells(directory ?? '', serverId)
+      const existing = queryClient.getQueryData<ShellRecord[]>(queryKey) ?? []
       return reconcileShellList(existing, fetched, fetchStartedAt, directory ?? '')
     },
     enabled,
@@ -52,13 +56,14 @@ export function useShell(shellID: string | undefined, directory: string | undefi
 }
 
 export function useKillShell(directory: string | undefined) {
+  const serverId = useOpenCodeServerId()
   const queryClient = useQueryClient()
 
   return useMutation({
-    mutationFn: (id: string) => removeShell(id, directory ?? ''),
+    mutationFn: (id: string) => removeShell(id, directory ?? '', serverId),
     onSuccess: (_result, id) => {
       recordShellExit(directory ?? '', { id, status: 'killed' })
-      queryClient.setQueryData<ShellRecord[]>(shellsQueryKey(directory), (current) =>
+      queryClient.setQueryData<ShellRecord[]>(serverScopedKey(shellsQueryKey(directory), serverId), (current) =>
         current && applyShellExit(current, { id, status: 'killed' }),
       )
     },
diff --git a/frontend/src/hooks/useSessionTranscript.test.tsx b/frontend/src/hooks/useSessionTranscript.test.tsx
index 344c99184..b88435a43 100644
--- a/frontend/src/hooks/useSessionTranscript.test.tsx
+++ b/frontend/src/hooks/useSessionTranscript.test.tsx
@@ -9,6 +9,7 @@ import type {
 } from '@opencode-manager/shared/opencode'
 import { useSessionTranscript } from './useSessionTranscript'
 import { ContextUsageIndicator } from '@/components/session/ContextUsageIndicator'
+import { OpenCodeServerProvider } from '@/contexts/OpenCodeServerContext'
 import { applySessionEvent, emptySessionTranscript } from '@/lib/session-projection'
 import type { TranscriptCache } from '@/lib/session-projection'
 import { sessionTranscriptQueryKey } from '@/lib/queryInvalidation'
@@ -31,6 +32,14 @@ const mocks = vi.hoisted(() => ({
   transport: null as unknown,
 }))
 
+const serverStatusMocks = vi.hoisted(() => ({
+  useOpenCodeServerStatuses: vi.fn(),
+}))
+
+vi.mock('@/hooks/useOpenCodeServers', () => ({
+  useOpenCodeServerStatuses: serverStatusMocks.useOpenCodeServerStatuses,
+}))
+
 vi.mock('@/api/opencode', () => ({
   listSessionMessages: mocks.listSessionMessages,
   readSessionSnapshot: mocks.readSessionSnapshot,
@@ -58,7 +67,7 @@ interface TestTransport {
   connected(): void
   fail(): void
   message(data: unknown): void
-  resync(): void
+  resync(payload?: unknown): void
 }
 
 function testTransport(): TestTransport {
@@ -114,9 +123,20 @@ function createQueryClient() {
   return new QueryClient({ defaultOptions: { queries: { retry: false } } })
 }
 
+function createRemoteWrapper(queryClient: QueryClient) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <QueryClientProvider client={queryClient}>
+        <OpenCodeServerProvider serverId="srv_remote">{children}</OpenCodeServerProvider>
+      </QueryClientProvider>
+    )
+  }
+}
+
 describe('useSessionTranscript', () => {
   beforeEach(() => {
     vi.clearAllMocks()
+    serverStatusMocks.useOpenCodeServerStatuses.mockReturnValue({ statusById: {} })
     mocks.readSessionSnapshot.mockReset()
     mocks.readSessionSnapshot.mockResolvedValue({
       messages: seededMessages,
@@ -216,6 +236,43 @@ describe('useSessionTranscript', () => {
     })
   })
 
+  it('ignores a resync scoped to another server', async () => {
+    const queryClient = createQueryClient()
+    const { result } = renderHook(() => useSessionTranscript(SESSION_ID, DIRECTORY), {
+      wrapper: createWrapper(queryClient),
+    })
+
+    await waitFor(() => expect(result.current.messages).toHaveLength(2))
+    expect(mocks.readSessionSnapshot).toHaveBeenCalledTimes(1)
+
+    await act(async () => {
+      testTransport().resync({ timestamp: Date.now(), serverId: 'srv_remote' })
+    })
+
+    expect(mocks.readSessionSnapshot).toHaveBeenCalledTimes(1)
+  })
+
+  it('refetches the newest page on a resync scoped to its own remote server', async () => {
+    const queryClient = createQueryClient()
+    const wrapper = function Wrapper({ children }: { children: ReactNode }) {
+      return (
+        <QueryClientProvider client={queryClient}>
+          <OpenCodeServerProvider serverId="srv_remote">{children}</OpenCodeServerProvider>
+        </QueryClientProvider>
+      )
+    }
+    const { result } = renderHook(() => useSessionTranscript(SESSION_ID, DIRECTORY), { wrapper })
+
+    await waitFor(() => expect(result.current.messages).toHaveLength(2))
+    expect(mocks.readSessionSnapshot).toHaveBeenCalledTimes(1)
+
+    await act(async () => {
+      testTransport().resync({ timestamp: Date.now(), serverId: 'srv_remote' })
+    })
+
+    await waitFor(() => expect(mocks.readSessionSnapshot).toHaveBeenCalledTimes(2))
+  })
+
   it('reads the newest page once on a fresh mount with no cached transcript', async () => {
     const queryClient = createQueryClient()
     const { result } = renderHook(() => useSessionTranscript(SESSION_ID, DIRECTORY), {
@@ -250,7 +307,7 @@ describe('useSessionTranscript', () => {
 
     await waitFor(() => expect(result.current.status).toBe('idle'))
     expect(mocks.readSessionSnapshot).toHaveBeenCalledTimes(2)
-    expect(mocks.readSessionSnapshot).toHaveBeenLastCalledWith(SECOND_SESSION_ID)
+    expect(mocks.readSessionSnapshot).toHaveBeenLastCalledWith(SECOND_SESSION_ID, 'local')
   })
 
   it('refreshes a stale cached transcript when the hook remounts', async () => {
@@ -556,6 +613,111 @@ describe('useSessionTranscript', () => {
     }
   })
 
+  it('polls a remote transcript while the remote server is disconnected even when the browser stream is connected', async () => {
+    vi.useFakeTimers()
+    try {
+      serverStatusMocks.useOpenCodeServerStatuses.mockReturnValue({
+        statusById: {
+          srv_remote: { serverId: 'srv_remote', connected: false, version: null, error: null },
+        },
+      })
+      const queryClient = createQueryClient()
+      const { result } = renderHook(() => useSessionTranscript(SESSION_ID, DIRECTORY), {
+        wrapper: createRemoteWrapper(queryClient),
+      })
+
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(0)
+      })
+      expect(result.current.messages).toHaveLength(2)
+
+      act(() => {
+        testTransport().connected()
+      })
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(0)
+      })
+      const readsAfterConnect = mocks.readSessionSnapshot.mock.calls.length
+
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(15000)
+      })
+      expect(mocks.readSessionSnapshot.mock.calls.length).toBeGreaterThan(readsAfterConnect)
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  it('stops polling a remote transcript once both the browser stream and the remote server are connected', async () => {
+    vi.useFakeTimers()
+    try {
+      serverStatusMocks.useOpenCodeServerStatuses.mockReturnValue({
+        statusById: {
+          srv_remote: { serverId: 'srv_remote', connected: true, version: null, error: null },
+        },
+      })
+      const queryClient = createQueryClient()
+      const { result } = renderHook(() => useSessionTranscript(SESSION_ID, DIRECTORY), {
+        wrapper: createRemoteWrapper(queryClient),
+      })
+
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(0)
+      })
+      expect(result.current.messages).toHaveLength(2)
+
+      act(() => {
+        testTransport().connected()
+      })
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(0)
+      })
+      const readsAfterConnect = mocks.readSessionSnapshot.mock.calls.length
+
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(15000)
+      })
+      expect(mocks.readSessionSnapshot.mock.calls.length).toBe(readsAfterConnect)
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  it('keeps the local transcript polling behavior independent of server statuses', async () => {
+    vi.useFakeTimers()
+    try {
+      serverStatusMocks.useOpenCodeServerStatuses.mockReturnValue({
+        statusById: {
+          local: { serverId: 'local', connected: false, version: null, error: null },
+        },
+      })
+      const queryClient = createQueryClient()
+      const { result } = renderHook(() => useSessionTranscript(SESSION_ID, DIRECTORY), {
+        wrapper: createWrapper(queryClient),
+      })
+
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(0)
+      })
+      expect(result.current.messages).toHaveLength(2)
+
+      act(() => {
+        testTransport().connected()
+      })
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(0)
+      })
+      const readsAfterConnect = mocks.readSessionSnapshot.mock.calls.length
+
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(15000)
+      })
+      expect(mocks.readSessionSnapshot.mock.calls.length).toBe(readsAfterConnect)
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
   it('reads the newest page once when execution ends while a tool is still running', async () => {
     const running = promptSequence.slice(0, 15).reduce(applySessionEvent, emptySessionTranscript)
     mocks.readSessionSnapshot.mockResolvedValue({
@@ -814,7 +976,7 @@ describe('useSessionTranscript', () => {
     act(() => {
       older = result.current.fetchOlder()
     })
-    expect(mocks.listSessionMessages).toHaveBeenCalledWith(SESSION_ID, { cursor: 'cursor_1' })
+    expect(mocks.listSessionMessages).toHaveBeenCalledWith(SESSION_ID, { cursor: 'cursor_1' }, 'local')
 
     const gapPage: SessionMessageInfo = {
       id: messageID(300),
@@ -861,7 +1023,7 @@ describe('useSessionTranscript', () => {
       await result.current.fetchOlder()
     })
 
-    expect(mocks.listSessionMessages).toHaveBeenLastCalledWith(SESSION_ID, { cursor: 'cursor_2' })
+    expect(mocks.listSessionMessages).toHaveBeenLastCalledWith(SESSION_ID, { cursor: 'cursor_2' }, 'local')
   })
 
   it('loads older pages with fetchOlder until the cursor is exhausted', async () => {
@@ -890,7 +1052,7 @@ describe('useSessionTranscript', () => {
       await result.current.fetchOlder()
     })
 
-    expect(mocks.listSessionMessages).toHaveBeenLastCalledWith(SESSION_ID, { cursor: 'cursor_1' })
+    expect(mocks.listSessionMessages).toHaveBeenLastCalledWith(SESSION_ID, { cursor: 'cursor_1' }, 'local')
     await waitFor(() => {
       expect(result.current.messages.map((message) => message.id)).toEqual([
         olderMessage.id,
diff --git a/frontend/src/hooks/useSessionTranscript.ts b/frontend/src/hooks/useSessionTranscript.ts
index 51605f570..4649a8499 100644
--- a/frontend/src/hooks/useSessionTranscript.ts
+++ b/frontend/src/hooks/useSessionTranscript.ts
@@ -1,9 +1,13 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { useQuery, useQueryClient } from '@tanstack/react-query'
 import { sessionIDFromEvent, type V2Event } from '@opencode-manager/shared/opencode'
+import { buildServerDirectoryKey, LOCAL_OPENCODE_SERVER_ID } from '@opencode-manager/shared/schemas'
 import { listSessionMessages, readSessionSnapshot } from '@/api/opencode'
 import { openCodeEventStream } from '@/lib/opencode-event-stream'
 import { sessionTranscriptQueryKey } from '@/lib/queryInvalidation'
+import { serverScopedKey } from '@/lib/serverScope'
+import { isLocalOpenCodeServer, useOpenCodeServerId } from '@/contexts/OpenCodeServerContext'
+import { useOpenCodeServerStatuses } from '@/hooks/useOpenCodeServers'
 import {
   applySessionEvents,
   emptySessionTranscript,
@@ -21,8 +25,13 @@ interface NewestPageRead {
 const TRANSCRIPT_FALLBACK_POLL_INTERVAL_MS = 5000
 
 export function useSessionTranscript(sessionID: string, directory: string) {
+  const serverId = useOpenCodeServerId()
+  const isRemoteServer = !isLocalOpenCodeServer(serverId)
   const queryClient = useQueryClient()
-  const queryKey = useMemo(() => sessionTranscriptQueryKey(sessionID), [sessionID])
+  const queryKey = useMemo(
+    () => serverScopedKey(sessionTranscriptQueryKey(sessionID), serverId),
+    [sessionID, serverId],
+  )
   const queuedEventsRef = useRef<V2Event[]>([])
   const frameRef = useRef<number | null>(null)
   const connectedRef = useRef<boolean | null>(null)
@@ -32,6 +41,8 @@ export function useSessionTranscript(sessionID: string, directory: string) {
   const cursorGenerationRef = useRef(0)
   const latestNewestReadRef = useRef<Promise<TranscriptCache> | null>(null)
   const [isStreamConnected, setIsStreamConnected] = useState(false)
+  const { statusById } = useOpenCodeServerStatuses({ enabled: isRemoteServer })
+  const isStreamHealthy = isStreamConnected && (!isRemoteServer || statusById[serverId]?.connected === true)
 
   const performNewestPageRead = useCallback(async (): Promise<TranscriptCache> => {
     const generation = (newestReadGenerationRef.current += 1)
@@ -42,7 +53,7 @@ export function useSessionTranscript(sessionID: string, directory: string) {
     newestReadRef.current = read
     let snapshot: SessionSnapshot
     try {
-      snapshot = await readSessionSnapshot(sessionID)
+      snapshot = await readSessionSnapshot(sessionID, serverId)
     } finally {
       if (newestReadRef.current === read) newestReadRef.current = null
     }
@@ -69,7 +80,7 @@ export function useSessionTranscript(sessionID: string, directory: string) {
     if (next.nextCursor !== current?.nextCursor) cursorGenerationRef.current += 1
     queryClient.setQueryData<TranscriptCache>(queryKey, next)
     return next
-  }, [queryClient, queryKey, sessionID])
+  }, [queryClient, queryKey, sessionID, serverId])
 
   const readNewestPage = useCallback((): Promise<TranscriptCache> => {
     const read = performNewestPageRead()
@@ -83,7 +94,7 @@ export function useSessionTranscript(sessionID: string, directory: string) {
     enabled: Boolean(sessionID && directory),
     staleTime: Infinity,
     refetchOnWindowFocus: false,
-    refetchInterval: isStreamConnected ? false : TRANSCRIPT_FALLBACK_POLL_INTERVAL_MS,
+    refetchInterval: isStreamHealthy ? false : TRANSCRIPT_FALLBACK_POLL_INTERVAL_MS,
   })
 
   const fetchOlder = useCallback(async () => {
@@ -92,7 +103,7 @@ export function useSessionTranscript(sessionID: string, directory: string) {
     fetchingOlderRef.current = true
     const generation = cursorGenerationRef.current
     try {
-      const page = await listSessionMessages(sessionID, { cursor })
+      const page = await listSessionMessages(sessionID, { cursor }, serverId)
       if (cursorGenerationRef.current !== generation) return
       queryClient.setQueryData<TranscriptCache>(queryKey, (current) => {
         if (!current) return current
@@ -109,7 +120,7 @@ export function useSessionTranscript(sessionID: string, directory: string) {
     } finally {
       fetchingOlderRef.current = false
     }
-  }, [queryClient, queryKey, sessionID])
+  }, [queryClient, queryKey, sessionID, serverId])
 
   useEffect(() => {
     if (!sessionID || !directory) return
@@ -134,9 +145,10 @@ export function useSessionTranscript(sessionID: string, directory: string) {
     }
 
     const subscription = openCodeEventStream.subscribeGlobalMonitor({
-      directories: [directory],
+      directories: [buildServerDirectoryKey(serverId, directory)],
       onEvent: (data) => {
-        const event = data as V2Event
+        const event = data as V2Event & { serverId?: string }
+        if ((event.serverId ?? LOCAL_OPENCODE_SERVER_ID) !== serverId) return
         if (sessionIDFromEvent(event) !== sessionID) return
         newestReadRef.current?.buffered.push(event)
         queuedEventsRef.current.push(event)
@@ -151,7 +163,10 @@ export function useSessionTranscript(sessionID: string, directory: string) {
         if (!connected || wasConnected !== false) return
         refreshNewestPage()
       },
-      onResync: refreshNewestPage,
+      onResync: (_subscribedDirectories: string[], resyncServerId?: string) => {
+        if ((resyncServerId ?? LOCAL_OPENCODE_SERVER_ID) !== serverId) return
+        refreshNewestPage()
+      },
     })
 
     if (queryClient.getQueryData<TranscriptCache>(queryKey)) {
@@ -170,7 +185,7 @@ export function useSessionTranscript(sessionID: string, directory: string) {
       newestReadRef.current = null
       subscription.dispose()
     }
-  }, [directory, queryClient, queryKey, readNewestPage, sessionID])
+  }, [directory, queryClient, queryKey, readNewestPage, sessionID, serverId])
 
   return {
     messages: query.data?.transcript.messages ?? [],
diff --git a/frontend/src/hooks/useSettingsDialog.ts b/frontend/src/hooks/useSettingsDialog.ts
index 07cc4bc75..f6f4f8c4e 100644
--- a/frontend/src/hooks/useSettingsDialog.ts
+++ b/frontend/src/hooks/useSettingsDialog.ts
@@ -1,7 +1,7 @@
 import { useCallback, useRef } from 'react'
 import { useUrlParams } from './useUrlParams'
 
-const SETTINGS_CONTENT_TABS = ['account', 'general', 'notifications', 'voice', 'git', 'shortcuts', 'opencode', 'providers', 'logs'] as const
+const SETTINGS_CONTENT_TABS = ['account', 'general', 'notifications', 'voice', 'git', 'shortcuts', 'servers', 'opencode', 'providers', 'logs'] as const
 
 export type SettingsContentTab = (typeof SETTINGS_CONTENT_TABS)[number]
 
diff --git a/frontend/src/hooks/useUndoMessage.ts b/frontend/src/hooks/useUndoMessage.ts
index 88891d486..e44d20753 100644
--- a/frontend/src/hooks/useUndoMessage.ts
+++ b/frontend/src/hooks/useUndoMessage.ts
@@ -1,5 +1,6 @@
 import { useMutation, useQueryClient } from '@tanstack/react-query'
 import { clearRevert, stageRevert } from '@/api/opencode'
+import { useOpenCodeServerId } from '@/contexts/OpenCodeServerContext'
 import { showToast } from '@/lib/toast'
 import { sessionTranscriptQueryKey } from '@/lib/queryInvalidation'
 
@@ -15,10 +16,11 @@ export function useUndoMessage({
   onSuccess
 }: UseUndoMessageOptions) {
   const queryClient = useQueryClient()
+  const serverId = useOpenCodeServerId()
 
   return useMutation<string, Error, { messageID: string; messageContent: string }>({
     mutationFn: async ({ messageID, messageContent }: { messageID: string, messageContent: string }) => {
-      await stageRevert(sessionId, messageID)
+      await stageRevert(sessionId, messageID, serverId)
       return messageContent
     },
     onError: () => {
@@ -41,9 +43,10 @@ interface UseRedoMessageOptions {
 
 export function useRedoMessage({ sessionId, directory }: UseRedoMessageOptions) {
   const queryClient = useQueryClient()
+  const serverId = useOpenCodeServerId()
 
   return useMutation({
-    mutationFn: async () => clearRevert(sessionId),
+    mutationFn: async () => clearRevert(sessionId, serverId),
     onError: () => {
       showToast.error('Failed to redo message')
     },
diff --git a/frontend/src/hooks/useVariants.test.tsx b/frontend/src/hooks/useVariants.test.tsx
index f3d5b57d8..d1ef27a9f 100644
--- a/frontend/src/hooks/useVariants.test.tsx
+++ b/frontend/src/hooks/useVariants.test.tsx
@@ -4,6 +4,7 @@ import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
 import type { ReactNode } from 'react'
 import { useVariants } from './useVariants'
 import { useModelStore } from '@/stores/modelStore'
+import { OpenCodeServerProvider } from '@/contexts/OpenCodeServerContext'
 import { modelStateQueryKey, useModelSelection, type ModelSelectionSession } from './useModelSelection'
 import * as providersApi from '@/api/providers'
 import type { Provider } from '@/api/providers'
@@ -320,4 +321,52 @@ describe('useVariants', () => {
     await waitFor(() => expect(result.current.variants.currentVariant).toBe('high'))
     expect(useModelStore.getState().sessionPicks.s1?.[AGENT_ID]).toBeUndefined()
   })
+
+  describe('remote server', () => {
+    const REMOTE_SERVER_ID = 'srv_remote'
+
+    const renderRemoteVariants = (queryClient: QueryClient, session?: ModelSelectionSession) =>
+      renderHook(() => useVariants(DIRECTORY, session), {
+        wrapper: ({ children }) => (
+          <QueryClientProvider client={queryClient}>
+            <OpenCodeServerProvider serverId={REMOTE_SERVER_ID}>{children}</OpenCodeServerProvider>
+          </QueryClientProvider>
+        ),
+      })
+
+    it('keeps a remote session variant in the session pick without persisting it', async () => {
+      selectAgentModel()
+      const { result } = renderRemoteVariants(createQueryClient(), {
+        id: 's1',
+        agent: AGENT_ID,
+        model: { providerID: PROVIDER_ID, id: MODEL_ID },
+      })
+
+      await waitFor(() => expect(result.current.hasVariants).toBe(true))
+
+      act(() => {
+        result.current.setVariant('high')
+      })
+
+      expect(useModelStore.getState().sessionPicks.s1[AGENT_ID].variant).toBe('high')
+      await waitFor(() => expect(result.current.currentVariant).toBe('high'))
+      expect(mockGetOpenCodeModelState).not.toHaveBeenCalled()
+      expect(mockSaveOpenCodeModelVariant).not.toHaveBeenCalled()
+    })
+
+    it('does not persist a remote variant outside a session', async () => {
+      selectAgentModel()
+      const { result } = renderRemoteVariants(createQueryClient())
+
+      await waitFor(() => expect(result.current.hasVariants).toBe(true))
+
+      act(() => {
+        result.current.setVariant('high')
+      })
+
+      expect(mockSaveOpenCodeModelVariant).not.toHaveBeenCalled()
+      expect(useModelStore.getState().newSessionPicks).toEqual({})
+      expect(result.current.currentVariant).toBeUndefined()
+    })
+  })
 })
diff --git a/frontend/src/hooks/useVariants.ts b/frontend/src/hooks/useVariants.ts
index be58d1447..eb4d7ad0a 100644
--- a/frontend/src/hooks/useVariants.ts
+++ b/frontend/src/hooks/useVariants.ts
@@ -1,6 +1,7 @@
 import { useCallback, useMemo } from 'react'
 import { useModelSelection, useModelStateMutation, type ModelSelectionSession } from './useModelSelection'
 import { useModelStore, type ModelSelection } from '@/stores/modelStore'
+import { isLocalOpenCodeServer, useOpenCodeServerId } from '@/contexts/OpenCodeServerContext'
 import { saveOpenCodeModelVariant } from '@/api/providers'
 import {
   cycleModelVariant,
@@ -27,6 +28,8 @@ export function useVariants(
   session?: ModelSelectionSession,
 ): UseVariantsResult {
   const { model, selection, info } = useModelSelection(directory, session)
+  const serverId = useOpenCodeServerId()
+  const isLocalServer = isLocalOpenCodeServer(serverId)
   const activeAgent = useModelStore((state) => state.activeAgent)
   const setSessionPick = useModelStore((state) => state.setSessionPick)
 
@@ -49,9 +52,9 @@ export function useVariants(
       if (session?.id && activeAgent?.id) {
         setSessionPick(session.id, activeAgent.id, { ...model, variant: normalizeModelVariant(variant) })
       }
-      saveVariant.mutate({ model, value: variant })
+      if (isLocalServer) saveVariant.mutate({ model, value: variant })
     },
-    [activeAgent?.id, model, saveVariant, session?.id, setSessionPick],
+    [activeAgent?.id, isLocalServer, model, saveVariant, session?.id, setSessionPick],
   )
 
   const cycleVariant = useCallback(
diff --git a/frontend/src/lib/activeWork.test.ts b/frontend/src/lib/activeWork.test.ts
index 0e7cbf11a..179b692e2 100644
--- a/frontend/src/lib/activeWork.test.ts
+++ b/frontend/src/lib/activeWork.test.ts
@@ -507,6 +507,72 @@ describe('buildActiveWork', () => {
 
     expect(runningGroups.running.map((item) => item.session.id)).toEqual(['sched'])
   })
+
+  it('emits a remote needs-input root with its server label and server session path', () => {
+    const sessions = [createSession('remote', NOW - 1000, '/home/me/app')]
+
+    const groups = buildActiveWork({
+      now: NOW,
+      windowMs: WINDOW_MS,
+      repos: [repoA],
+      sessions,
+      parents: new Map(),
+      roots: { needsInput: new Set(['remote']), running: new Set() },
+      outcomes: new Map(),
+      sessionServers: new Map([['remote', 'srv_kitchen']]),
+      serverNames: new Map([['srv_kitchen', 'Kitchen']]),
+    })
+
+    expect(groups.needsInput).toHaveLength(1)
+    expect(groups.needsInput[0].repo).toBeNull()
+    expect(groups.needsInput[0].serverId).toBe('srv_kitchen')
+    expect(groups.needsInput[0].serverName).toBe('Kitchen')
+    expect(groups.needsInput[0].path).toBe('/servers/srv_kitchen/sessions/remote')
+  })
+
+  it('emits a running remote root and rolls its remote child up to it', () => {
+    const parents = new Map<string, string | null>([
+      ['remote-root', null],
+      ['remote-child', 'remote-root'],
+    ])
+    const sessions = [
+      createSession('remote-root', NOW - 4000, '/home/me/app'),
+      createSession('remote-child', NOW - 1000, '/home/me/app', 'remote-root'),
+    ]
+
+    const groups = buildActiveWork({
+      now: NOW,
+      windowMs: WINDOW_MS,
+      repos: [repoA],
+      sessions,
+      parents,
+      roots: { needsInput: new Set(), running: new Set(['remote-root']) },
+      outcomes: new Map(),
+      sessionServers: new Map([['remote-root', 'srv_kitchen']]),
+      serverNames: new Map([['srv_kitchen', 'Kitchen']]),
+    })
+
+    expect(groups.running.map((item) => item.session.id)).toEqual(['remote-root'])
+    expect(groups.running[0].updatedAt).toBe(NOW - 1000)
+    expect(groups.recent).toEqual([])
+  })
+
+  it('never emits a recent row for a remote session', () => {
+    const sessions = [createSession('remote', NOW - 1000, '/home/me/app')]
+
+    const groups = buildActiveWork({
+      now: NOW,
+      windowMs: WINDOW_MS,
+      repos: [repoA],
+      sessions,
+      parents: new Map(),
+      roots: emptyRoots,
+      outcomes: new Map(),
+      sessionServers: new Map([['remote', 'srv_kitchen']]),
+    })
+
+    expect(groups).toEqual({ needsInput: [], running: [], recent: [] })
+  })
 })
 
 describe('needsWorktreeLookup', () => {
diff --git a/frontend/src/lib/activeWork.ts b/frontend/src/lib/activeWork.ts
index 541e646d8..fce74ea19 100644
--- a/frontend/src/lib/activeWork.ts
+++ b/frontend/src/lib/activeWork.ts
@@ -1,12 +1,23 @@
 import type { Repo, Session } from '@/api/types'
+import { LOCAL_OPENCODE_SERVER_ID, parseServerDirectoryKey } from '@opencode-manager/shared/schemas'
 import type { ChildOutcome } from '@/lib/backgroundWork'
 import type { SessionStatusType } from '@/stores/sessionStatusStore'
 import { getSessionKey } from '@/lib/sessionKey'
-import { getSessionPath } from '@/lib/navigation'
+import { getServerSessionPath, getSessionPath } from '@/lib/navigation'
 import { getRepoBranchLabel } from '@/lib/utils'
 import { findRepoForDirectory, normalizeDirectory } from '@/components/navigation/sidebar-session-tree'
 import { isWorktreeSibling, type RepoSibling } from '@opencode-manager/shared/utils'
 
+/**
+ * The plain directory of a session-status directory value when it belongs to the local server,
+ * or null for a remote session's server-keyed directory.
+ */
+function localDirectoryOf(directory?: string | null): string | null {
+  if (!directory) return null
+  const { serverId, directory: parsed } = parseServerDirectoryKey(directory)
+  return serverId === LOCAL_OPENCODE_SERVER_ID ? parsed : null
+}
+
 export const MS_PER_MINUTE = 60_000
 
 /**
@@ -32,7 +43,12 @@ export type ActiveWorkState = 'needs-input' | 'running' | 'recent'
 export interface ActiveWorkItem {
   key: string
   session: Session
-  repo: Repo
+  /** The local repo the session runs in; null for a session owned by a linked server. */
+  repo: Repo | null
+  /** The linked server that owns the session; null for a local repo session. */
+  serverId: string | null
+  /** The owning linked server's display name; null for a local repo session. */
+  serverName: string | null
   state: ActiveWorkState
   updatedAt: number
   outcome?: ChildOutcome
@@ -116,12 +132,12 @@ function computeRepoActivityIndex(input: RepoActivityIndexInput): Map<string, 'n
   const index = new Map<string, 'needs-input' | 'running'>()
 
   const markNeedsInput = (directory?: string | null): void => {
-    const normalized = normalizeDirectory(directory)
+    const normalized = normalizeDirectory(localDirectoryOf(directory))
     if (normalized) index.set(normalized, 'needs-input')
   }
 
   const markRunning = (directory?: string | null): void => {
-    const normalized = normalizeDirectory(directory)
+    const normalized = normalizeDirectory(localDirectoryOf(directory))
     if (!normalized || index.get(normalized) === 'needs-input') return
     index.set(normalized, 'running')
   }
@@ -288,12 +304,14 @@ export function needsWorktreeLookup(input: {
   sessions: Session[]
   parents: ReadonlyMap<string, string | null>
   roots: { needsInput: Set<string>; running: Set<string> }
+  sessionServers?: ReadonlyMap<string, string>
 }): boolean {
-  const { now, windowMs, repos, sessions, parents, roots } = input
+  const { now, windowMs, repos, sessions, parents, roots, sessionServers } = input
   const windowStart = now - windowMs
 
   return sessions.some((session) => {
     if (session.time.archived) return false
+    if (sessionServers?.has(session.id)) return false
     if (findRepoForDirectory(repos, session.location.directory)) return false
     if (session.time.updated >= windowStart) return true
     const rootID = rootSessionID(session.id, parents)
@@ -303,10 +321,12 @@ export function needsWorktreeLookup(input: {
 
 /**
  * Groups the given sessions into needs-input, running, and recent roots. A session appears in
- * exactly one group (needs-input over running over recent) and only when it resolves to a repo.
- * A recent session in a schedule worktree is omitted so schedules only surface while they need
- * attention. The input may mix roots and children; children never become items, but their latest
- * update time rolls up into the root's `updatedAt` and decides the recent window and ordering.
+ * exactly one group (needs-input over running over recent) and only when it resolves to a local
+ * repo or to an owning linked server. A session owned by a linked server is only emitted while it
+ * needs input or is running, so remote work never fills the recent window. A recent session in a
+ * schedule worktree is omitted so schedules only surface while they need attention. The input may
+ * mix roots and children; children never become items, but their latest update time rolls up into
+ * the root's `updatedAt` and decides the recent window and ordering.
  */
 export function buildActiveWork(input: {
   now: number
@@ -317,8 +337,10 @@ export function buildActiveWork(input: {
   roots: { needsInput: Set<string>; running: Set<string> }
   outcomes: ReadonlyMap<string, ChildOutcome>
   worktrees?: ReadonlyArray<ActiveWorktree>
+  sessionServers?: ReadonlyMap<string, string>
+  serverNames?: ReadonlyMap<string, string>
 }): ActiveWorkGroups {
-  const { now, windowMs, repos, sessions, parents, roots, outcomes, worktrees } = input
+  const { now, windowMs, repos, sessions, parents, roots, outcomes, worktrees, sessionServers, serverNames } = input
   const windowStart = now - windowMs
 
   const worktreeByDirectory = new Map<string, ActiveWorktree>()
@@ -356,6 +378,27 @@ export function buildActiveWork(input: {
           : null
     if (!state) continue
 
+    const serverId = sessionServers?.get(session.id) ?? null
+    if (serverId) {
+      if (state === 'recent') continue
+      seen.add(session.id)
+      const item: ActiveWorkItem = {
+        key: getSessionKey(session),
+        session,
+        repo: null,
+        serverId,
+        serverName: serverNames?.get(serverId) ?? null,
+        state,
+        updatedAt,
+        outcome: outcomes.get(session.id),
+        worktreeBranch: null,
+        path: getServerSessionPath(serverId, session.id),
+      }
+      if (state === 'needs-input') needsInput.push(item)
+      else running.push(item)
+      continue
+    }
+
     const directory = normalizeDirectory(session.location.directory)
     const worktree = directory ? worktreeByDirectory.get(directory) : undefined
     const repo = worktree?.ownerRepo ?? findRepoForDirectory(repos, session.location.directory)
@@ -367,6 +410,8 @@ export function buildActiveWork(input: {
       key: getSessionKey(session),
       session,
       repo,
+      serverId: null,
+      serverName: null,
       state,
       updatedAt,
       outcome: outcomes.get(session.id),
diff --git a/frontend/src/lib/builtinCommands.ts b/frontend/src/lib/builtinCommands.ts
index 4cb21947f..923172fb1 100644
--- a/frontend/src/lib/builtinCommands.ts
+++ b/frontend/src/lib/builtinCommands.ts
@@ -67,3 +67,17 @@ export const BUILTIN_COMMANDS: readonly BuiltinCommand[] = [
 export function isBuiltinCommand(command: CommandInfo): command is BuiltinCommand {
   return 'action' in command
 }
+
+const MANAGER_ONLY_COMMAND_ACTIONS: ReadonlySet<BuiltinCommandAction> = new Set([
+  'showSessions',
+  'showWalkthrough',
+])
+
+/**
+ * Built-in composer commands for a server scope. Commands backed by Manager-only features are omitted for
+ * linked OpenCode servers; MCP and skills stay because their views work against the linked server.
+ */
+export function getBuiltinCommands(isLocalServer: boolean): readonly BuiltinCommand[] {
+  if (isLocalServer) return BUILTIN_COMMANDS
+  return BUILTIN_COMMANDS.filter((command) => !MANAGER_ONLY_COMMAND_ACTIONS.has(command.action))
+}
diff --git a/frontend/src/lib/navigation.test.ts b/frontend/src/lib/navigation.test.ts
index 2733333bf..118351cff 100644
--- a/frontend/src/lib/navigation.test.ts
+++ b/frontend/src/lib/navigation.test.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { getSessionListPath, getSwipeBackTarget, getAssistantPath, getAssistantSessionListPath, isAssistantPath, getPathWithReturnTo, getReturnToPath, getRepoPath, getSessionPath, parseRepoRoute } from './navigation';
+import { getSessionListPath, getSwipeBackTarget, getAssistantPath, getAssistantSessionListPath, isAssistantPath, getPathWithReturnTo, getReturnToPath, getRepoPath, getServerPath, getServerSessionPath, getSessionPath, parseRepoRoute, parseServerSessionRoute } from './navigation';
 
 describe('getAssistantPath', () => {
   it('returns /assistant', () => {
@@ -80,6 +80,27 @@ describe('getSessionPath', () => {
       '/repos/0/sessions/ses_1?assistant=1&repoTab=workspaces'
     );
   });
+
+  it('builds a linked server session path for a remote server id', () => {
+    expect(getSessionPath(0, 'ses_1', { serverId: 'srv_kitchen' })).toBe(
+      '/servers/srv_kitchen/sessions/ses_1'
+    );
+    expect(getSessionPath(5, 'ses_1', { repoTab: 'workspaces', serverId: 'srv_kitchen' })).toBe(
+      '/servers/srv_kitchen/sessions/ses_1'
+    );
+  });
+
+  it('keeps local repo paths when the server id is local', () => {
+    expect(getSessionPath(5, 'ses_1', { serverId: 'local' })).toBe('/repos/5/sessions/ses_1');
+  });
+});
+
+describe('linked server paths', () => {
+  it('builds server and server session paths with encoded segments', () => {
+    expect(getServerPath('srv_kitchen')).toBe('/servers/srv_kitchen');
+    expect(getServerSessionPath('srv_kitchen', 'ses_1')).toBe('/servers/srv_kitchen/sessions/ses_1');
+    expect(getServerSessionPath('srv a/b', 'ses 1')).toBe('/servers/srv%20a%2Fb/sessions/ses%201');
+  });
 });
 
 describe('getRepoPath', () => {
@@ -120,6 +141,35 @@ describe('parseRepoRoute', () => {
   });
 });
 
+describe('parseServerSessionRoute', () => {
+  it('parses a linked-server session route', () => {
+    expect(parseServerSessionRoute('/servers/srv_kitchen/sessions/ses_1')).toEqual({
+      serverId: 'srv_kitchen',
+      sessionId: 'ses_1',
+    });
+  });
+
+  it('returns null for other routes', () => {
+    expect(parseServerSessionRoute('/servers/srv_kitchen')).toBeNull();
+    expect(parseServerSessionRoute('/repos/5/sessions/ses_1')).toBeNull();
+  });
+
+  it('returns null for a malformed server id segment', () => {
+    expect(parseServerSessionRoute('/servers/%E0%A4%A/sessions/ses_1')).toBeNull();
+  });
+
+  it('returns null for a malformed session id segment', () => {
+    expect(parseServerSessionRoute('/servers/srv_kitchen/sessions/%E0%A4%A')).toBeNull();
+  });
+
+  it('decodes valid encoded segments', () => {
+    expect(parseServerSessionRoute('/servers/srv%20a%2Fb/sessions/ses%201')).toEqual({
+      serverId: 'srv a/b',
+      sessionId: 'ses 1',
+    });
+  });
+});
+
 describe('return target helpers', () => {
   it('adds encoded returnTo params for internal paths', () => {
     expect(getPathWithReturnTo('/repos/5/schedules', '/repos/5/sessions/abc?assistant=1')).toBe(
@@ -174,6 +224,23 @@ describe('getSwipeBackTarget', () => {
     });
   });
 
+  describe('linked server routes', () => {
+    it('returns the server page for a remote session detail', () => {
+      expect(getSwipeBackTarget('/servers/srv_kitchen/sessions/ses_1', '')).toBe('/servers/srv_kitchen');
+    });
+
+    it('returns root for a server page', () => {
+      expect(getSwipeBackTarget('/servers/srv_kitchen', '')).toBe('/');
+    });
+
+    it('does not throw for a malformed server session path', () => {
+      expect(() => getSwipeBackTarget('/servers/%E0%A4%A/sessions/ses_1', '')).not.toThrow();
+      expect(getSwipeBackTarget('/servers/%E0%A4%A/sessions/ses_1', '')).toBeNull();
+      expect(() => getSwipeBackTarget('/servers/srv_kitchen/sessions/%E0%A4%A', '')).not.toThrow();
+      expect(getSwipeBackTarget('/servers/srv_kitchen/sessions/%E0%A4%A', '')).toBeNull();
+    });
+  });
+
   describe('repo route', () => {
     it('returns root for repo detail', () => {
       expect(getSwipeBackTarget('/repos/42', '')).toBe('/');
diff --git a/frontend/src/lib/navigation.ts b/frontend/src/lib/navigation.ts
index 6ed09ccbf..98eee7a99 100644
--- a/frontend/src/lib/navigation.ts
+++ b/frontend/src/lib/navigation.ts
@@ -1,4 +1,5 @@
 import { ASSISTANT_REPO_ID, buildSessionPath } from '@opencode-manager/shared/utils';
+import { LOCAL_OPENCODE_SERVER_ID } from '@opencode-manager/shared/schemas';
 
 export function getAssistantPath(): string {
   return '/assistant';
@@ -20,10 +21,38 @@ export function getRepoPath(repoId: number | string): string {
   return isAssistantRepo(repoId) ? getAssistantPath() : `/repos/${repoId}`;
 }
 
-export function getSessionPath(repoId: number | string, sessionId: string, options?: { repoTab?: string }): string {
+export function getSessionPath(repoId: number | string, sessionId: string, options?: { repoTab?: string; serverId?: string }): string {
+  if (options?.serverId && options.serverId !== LOCAL_OPENCODE_SERVER_ID) {
+    return getServerSessionPath(options.serverId, sessionId);
+  }
   return buildSessionPath(repoId, sessionId, options);
 }
 
+export function getServerPath(serverId: string): string {
+  return `/servers/${encodeURIComponent(serverId)}`;
+}
+
+export function getServerSessionPath(serverId: string, sessionId: string): string {
+  return `${getServerPath(serverId)}/sessions/${encodeURIComponent(sessionId)}`;
+}
+
+function decodePathSegment(segment: string): string | null {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return null;
+  }
+}
+
+export function parseServerSessionRoute(pathname: string): { serverId: string; sessionId: string } | null {
+  const match = /^\/servers\/([^/]+)\/sessions\/([^/]+)$/.exec(pathname);
+  if (!match) return null;
+  const serverId = decodePathSegment(match[1]);
+  const sessionId = decodePathSegment(match[2]);
+  if (serverId === null || sessionId === null) return null;
+  return { serverId, sessionId };
+}
+
 export function parseRepoRoute(pathname: string): { repoId: number | null; section: string | null; sessionId: string | null } {
   const match = /^\/repos\/(\d+)(?:\/([^/]+)(?:\/([^/]+))?)?/.exec(pathname);
   if (!match) {
@@ -72,6 +101,15 @@ export function getReturnToPath(search: string, fallback: string): string {
 }
 
 export function getSwipeBackTarget(pathname: string, search = ''): string | null {
+  const serverSession = parseServerSessionRoute(pathname);
+  if (serverSession) {
+    return getServerPath(serverSession.serverId);
+  }
+
+  if (/^\/servers\/[^/]+$/.test(pathname)) {
+    return '/';
+  }
+
   const sessionDetailRegex = /^\/repos\/([^/]+)\/sessions\/[^/]+$/;
   const match = pathname.match(sessionDetailRegex);
 
diff --git a/frontend/src/lib/opencode-event-stream/__tests__/openCodeEventStream.test.ts b/frontend/src/lib/opencode-event-stream/__tests__/openCodeEventStream.test.ts
index e86fdfcff..00ef9d324 100644
--- a/frontend/src/lib/opencode-event-stream/__tests__/openCodeEventStream.test.ts
+++ b/frontend/src/lib/opencode-event-stream/__tests__/openCodeEventStream.test.ts
@@ -67,6 +67,34 @@ describe('OpenCodeEventStream', () => {
     expect(onEvent).toHaveBeenNthCalledWith(2, { type: 'credential.updated', data: {} })
   })
 
+  it('copies the envelope server id onto remote events only', () => {
+    const transport = new TestEventStreamTransport()
+    const stream = new OpenCodeEventStream({ transport })
+    const onEvent = vi.fn()
+
+    stream.subscribeGlobalMonitor({ directories: ['/repo'], onEvent })
+    transport.openConnection()
+    transport.connected()
+    transport.message({
+      directory: '/repo',
+      serverId: 'srv_abc',
+      payload: { type: 'session.created', data: { sessionID: 'session-1' } },
+    })
+    transport.message({ directory: '/repo', payload: { type: 'session.idle', data: { sessionID: 'session-1' } } })
+
+    expect(onEvent).toHaveBeenNthCalledWith(1, {
+      type: 'session.created',
+      data: { sessionID: 'session-1' },
+      directory: '/repo',
+      serverId: 'srv_abc',
+    })
+    expect(onEvent).toHaveBeenNthCalledWith(2, {
+      type: 'session.idle',
+      data: { sessionID: 'session-1' },
+      directory: '/repo',
+    })
+  })
+
   it('publishes health through monitor output', () => {
     const transport = new TestEventStreamTransport()
     const stream = new OpenCodeEventStream({ transport })
@@ -193,7 +221,20 @@ describe('OpenCodeEventStream', () => {
     transport.resync()
 
     expect(onResync).toHaveBeenCalledTimes(1)
-    expect(onResync).toHaveBeenCalledWith(['/repo'])
+    expect(onResync).toHaveBeenCalledWith(['/repo'], undefined)
+  })
+
+  it('passes the server id of a remote resync to the global monitor', () => {
+    const transport = new TestEventStreamTransport()
+    const stream = new OpenCodeEventStream({ transport })
+    const onResync = vi.fn()
+
+    stream.subscribeGlobalMonitor({ directories: ['/repo'], onEvent: vi.fn(), onResync })
+    transport.openConnection()
+    transport.connected()
+    transport.resync({ timestamp: 1, serverId: 'srv_remote' })
+
+    expect(onResync).toHaveBeenCalledWith(['/repo'], 'srv_remote')
   })
 
   it('reports visibility through the transport adapter', async () => {
diff --git a/frontend/src/lib/opencode-event-stream/browserTransport.ts b/frontend/src/lib/opencode-event-stream/browserTransport.ts
index 9c668fe98..5d4c9cf84 100644
--- a/frontend/src/lib/opencode-event-stream/browserTransport.ts
+++ b/frontend/src/lib/opencode-event-stream/browserTransport.ts
@@ -12,7 +12,9 @@ export function createBrowserEventStreamTransport(): EventStreamTransport {
         handlers.onConnected((event as MessageEvent).data)
       })
       eventSource.addEventListener('heartbeat', handlers.onHeartbeat)
-      eventSource.addEventListener('resync', handlers.onResync)
+      eventSource.addEventListener('resync', (event) => {
+        handlers.onResync((event as MessageEvent).data)
+      })
 
       return {
         close: () => eventSource.close(),
diff --git a/frontend/src/lib/opencode-event-stream/openCodeEventStream.ts b/frontend/src/lib/opencode-event-stream/openCodeEventStream.ts
index 3dc4bf7f0..946de4d0a 100644
--- a/frontend/src/lib/opencode-event-stream/openCodeEventStream.ts
+++ b/frontend/src/lib/opencode-event-stream/openCodeEventStream.ts
@@ -1,5 +1,5 @@
 import { DEFAULTS } from '@opencode-manager/shared/config'
-import type { SSEEventEnvelope } from '@opencode-manager/shared'
+import type { SSEEventEnvelope } from '@opencode-manager/shared/schemas'
 import { createBrowserEventStreamTransport } from './browserTransport'
 import type {
   EventStreamHealthState,
@@ -14,7 +14,7 @@ interface Subscriber {
   onEvent: OpenCodeEventHandler
   onStatusChange?: EventStreamStatusHandler
   onHealthChange?: (state: EventStreamHealthState) => void
-  onResync?: (subscribedDirectories: string[]) => void
+  onResync?: (subscribedDirectories: string[], serverId?: string) => void
   onDirectoriesSubscribed?: (directories: string[]) => void
   directories: Set<string>
 }
@@ -24,7 +24,7 @@ interface SubscriberInput {
   onStatusChange?: EventStreamStatusHandler
   onHealthChange?: (state: EventStreamHealthState) => void
   directories: string[]
-  onResync?: (subscribedDirectories: string[]) => void
+  onResync?: (subscribedDirectories: string[], serverId?: string) => void
   onDirectoriesSubscribed?: (directories: string[]) => void
 }
 
@@ -213,7 +213,7 @@ export class OpenCodeEventStream {
       onMessage: (data) => this.handleMessage(data),
       onConnected: (data) => this.handleConnected(data),
       onHeartbeat: () => this.markActivity(),
-      onResync: () => this.handleResync(),
+      onResync: (data) => this.handleResync(data),
     })
     this.startConnectTimeout()
   }
@@ -413,12 +413,13 @@ export class OpenCodeEventStream {
     })
   }
 
-  private handleResync(): void {
+  private handleResync(data?: string): void {
     this.markActivity()
     const directories = Array.from(this.directoryRefCounts.keys())
+    const serverId = parseResyncServerId(data)
     this.subscribers.forEach((subscriber) => {
       try {
-        subscriber.onResync?.(directories)
+        subscriber.onResync?.(directories, serverId)
       } catch {
         void 0
       }
@@ -489,6 +490,16 @@ export class OpenCodeEventStream {
   }
 }
 
+function parseResyncServerId(data?: string): string | undefined {
+  if (!data) return undefined
+  try {
+    const parsed = JSON.parse(data) as { serverId?: unknown }
+    return typeof parsed.serverId === 'string' ? parsed.serverId : undefined
+  } catch {
+    return undefined
+  }
+}
+
 function flattenEventEnvelope(parsed: unknown): unknown {
   if (
     parsed !== null &&
@@ -497,8 +508,12 @@ function flattenEventEnvelope(parsed: unknown): unknown {
     (parsed as { payload: unknown }).payload !== null &&
     typeof (parsed as { payload: unknown }).payload === 'object'
   ) {
-    const { payload, directory } = parsed as SSEEventEnvelope
-    return typeof directory === 'string' ? { ...payload, directory } : { ...payload }
+    const { payload, directory, serverId } = parsed as SSEEventEnvelope
+    return {
+      ...payload,
+      ...(typeof directory === 'string' ? { directory } : {}),
+      ...(typeof serverId === 'string' ? { serverId } : {}),
+    }
   }
   return parsed
 }
diff --git a/frontend/src/lib/opencode-event-stream/testTransport.ts b/frontend/src/lib/opencode-event-stream/testTransport.ts
index 8053924ee..d9f9dae91 100644
--- a/frontend/src/lib/opencode-event-stream/testTransport.ts
+++ b/frontend/src/lib/opencode-event-stream/testTransport.ts
@@ -46,8 +46,8 @@ export class TestEventStreamTransport implements EventStreamTransport {
     this.handlers?.onHeartbeat()
   }
 
-  resync(): void {
-    this.handlers?.onResync()
+  resync(payload?: unknown): void {
+    this.handlers?.onResync(payload === undefined ? undefined : JSON.stringify(payload))
   }
 
   fail(): void {
diff --git a/frontend/src/lib/opencode-event-stream/types.ts b/frontend/src/lib/opencode-event-stream/types.ts
index 2d2620cca..34da208a1 100644
--- a/frontend/src/lib/opencode-event-stream/types.ts
+++ b/frontend/src/lib/opencode-event-stream/types.ts
@@ -18,7 +18,7 @@ export interface EventStreamTransportHandlers {
   onMessage(data: string): void
   onConnected(data: string): void
   onHeartbeat(): void
-  onResync(): void
+  onResync(data?: string): void
 }
 
 export interface EventStreamTransport {
diff --git a/frontend/src/lib/serverScope.test.ts b/frontend/src/lib/serverScope.test.ts
new file mode 100644
index 000000000..237fde9c7
--- /dev/null
+++ b/frontend/src/lib/serverScope.test.ts
@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest'
+import { serverScopedKey } from './serverScope'
+
+describe('serverScopedKey', () => {
+  it('returns the same key for the local server', () => {
+    const key = ['opencode', 'sessions', '/repo']
+
+    expect(serverScopedKey(key, 'local')).toBe(key)
+    expect(serverScopedKey(key)).toBe(key)
+  })
+
+  it('appends the server id last for remote servers', () => {
+    expect(serverScopedKey(['opencode', 'sessions', '/repo'], 'srv_abc')).toEqual([
+      'opencode',
+      'sessions',
+      '/repo',
+      'srv_abc',
+    ])
+  })
+})
diff --git a/frontend/src/lib/serverScope.ts b/frontend/src/lib/serverScope.ts
new file mode 100644
index 000000000..3fea62c8c
--- /dev/null
+++ b/frontend/src/lib/serverScope.ts
@@ -0,0 +1,12 @@
+import { LOCAL_OPENCODE_SERVER_ID } from '@opencode-manager/shared/schemas'
+
+/**
+ * Returns the query key for a server-scoped cache entry. Local keys stay untouched so existing
+ * prefix-based invalidations keep matching; remote keys get the server id appended last.
+ */
+export function serverScopedKey(
+  key: readonly unknown[],
+  serverId: string = LOCAL_OPENCODE_SERVER_ID,
+): readonly unknown[] {
+  return serverId === LOCAL_OPENCODE_SERVER_ID ? key : [...key, serverId]
+}
diff --git a/frontend/src/lib/utils.ts b/frontend/src/lib/utils.ts
index a4b34ccd9..94d6259ae 100644
--- a/frontend/src/lib/utils.ts
+++ b/frontend/src/lib/utils.ts
@@ -41,6 +41,11 @@ export function shortenPath(path: string, maxSegments = 3): string {
   return `/.../${segments.slice(-maxSegments).join('/')}`
 }
 
+/** Returns the final segment of a directory path, or the path itself when it has none. */
+export function getDirectoryName(path: string): string {
+  return path.split('/').filter(Boolean).at(-1) ?? path
+}
+
 export function randomId(): string {
   if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
     return crypto.randomUUID()
diff --git a/frontend/src/pages/RemoteServer.tsx b/frontend/src/pages/RemoteServer.tsx
new file mode 100644
index 000000000..8e2a5ce8f
--- /dev/null
+++ b/frontend/src/pages/RemoteServer.tsx
@@ -0,0 +1,329 @@
+import { useState, type FormEvent } from 'react'
+import { Link, useNavigate, useParams } from 'react-router-dom'
+import { useQuery } from '@tanstack/react-query'
+import { formatDistanceToNow } from 'date-fns'
+import {
+  ChevronDown,
+  ChevronRight,
+  FolderGit2,
+  Loader2,
+  Plus,
+  Server,
+  Settings,
+} from 'lucide-react'
+import type { OpenCodeServerStatus } from '@opencode-manager/shared/schemas'
+import { listProjects, type OpenCodeProject } from '@/api/opencode'
+import { useCreateSession, useSessionsAcrossDirectories } from '@/hooks/useOpenCode'
+import { useOpenCodeServers, useOpenCodeServerStatuses } from '@/hooks/useOpenCodeServers'
+import { useSettingsDialog } from '@/hooks/useSettingsDialog'
+import { useSSE } from '@/hooks/useSSE'
+import { serverScopedKey } from '@/lib/serverScope'
+import { getServerSessionPath } from '@/lib/navigation'
+import { getDirectoryName } from '@/lib/utils'
+import { Header } from '@/components/ui/header'
+import { Badge } from '@/components/ui/badge'
+import { Button } from '@/components/ui/button'
+import { Card } from '@/components/ui/card'
+import { Input } from '@/components/ui/input'
+import { SessionStatusIndicator } from '@/components/ui/session-status-indicator'
+
+function ConnectionStatus({ status, isLoading }: { status?: OpenCodeServerStatus; isLoading: boolean }) {
+  if (isLoading) {
+    return <span className="text-xs text-muted-foreground">Checking connection...</span>
+  }
+
+  if (!status) {
+    return (
+      <span className="flex items-center gap-1.5 text-xs text-muted-foreground">
+        <span className="h-2 w-2 rounded-full bg-muted-foreground/50" />
+        Unknown
+      </span>
+    )
+  }
+
+  if (!status.connected) {
+    return (
+      <span className="flex items-center gap-1.5 text-xs text-destructive" title={status.error ?? undefined}>
+        <span className="h-2 w-2 rounded-full bg-destructive" />
+        Unreachable
+        {status.error ? <span className="text-muted-foreground">· {status.error}</span> : null}
+      </span>
+    )
+  }
+
+  return (
+    <span className="flex items-center gap-1.5 text-xs text-success">
+      <span className="h-2 w-2 rounded-full bg-success" />
+      Connected
+      {status.version ? <span className="text-muted-foreground">· v{status.version}</span> : null}
+    </span>
+  )
+}
+
+function ProjectSessions({ serverId, directory }: { serverId: string; directory: string }) {
+  useSSE(directory)
+  const { data: sessions, isLoading } = useSessionsAcrossDirectories([directory])
+
+  if (isLoading) {
+    return (
+      <div className="flex items-center gap-2 px-3 py-3 text-sm text-muted-foreground">
+        <Loader2 className="h-4 w-4 animate-spin" />
+        Loading sessions...
+      </div>
+    )
+  }
+
+  if (sessions.length === 0) {
+    return <p className="px-3 py-3 text-sm text-muted-foreground">No sessions in this project yet.</p>
+  }
+
+  return (
+    <ul className="flex flex-col gap-1 px-2 pb-2">
+      {sessions.map((session) => (
+        <li key={session.id}>
+          <Link
+            to={getServerSessionPath(serverId, session.id)}
+            className="flex items-center justify-between gap-3 rounded-md px-3 py-2 text-sm transition-colors hover:bg-accent"
+          >
+            <span className="min-w-0 flex items-center gap-2">
+              <SessionStatusIndicator sessionID={session.id} size="sm" />
+              <span className="truncate font-medium">{session.title || 'Untitled Session'}</span>
+            </span>
+            <span className="shrink-0 text-xs text-muted-foreground">
+              {formatDistanceToNow(new Date(session.time.updated), { addSuffix: true })}
+            </span>
+          </Link>
+        </li>
+      ))}
+    </ul>
+  )
+}
+
+function ProjectRow({ project, serverId }: { project: OpenCodeProject; serverId: string }) {
+  const navigate = useNavigate()
+  const [expanded, setExpanded] = useState(false)
+  const createSession = useCreateSession(project.canonical)
+  const name = project.name?.trim() || getDirectoryName(project.canonical)
+
+  const handleNewSession = async () => {
+    try {
+      const session = await createSession.mutateAsync({ agent: undefined })
+      navigate(getServerSessionPath(serverId, session.id))
+    } catch {
+      return
+    }
+  }
+
+  return (
+    <Card className="overflow-hidden">
+      <div className="flex items-center gap-2 p-2">
+        <button
+          type="button"
+          onClick={() => setExpanded((current) => !current)}
+          aria-expanded={expanded}
+          className="flex min-w-0 flex-1 items-center gap-2 rounded-md p-1 text-left transition-colors hover:bg-accent/50"
+        >
+          {expanded ? (
+            <ChevronDown className="h-4 w-4 shrink-0 text-muted-foreground" />
+          ) : (
+            <ChevronRight className="h-4 w-4 shrink-0 text-muted-foreground" />
+          )}
+          <FolderGit2 className="h-4 w-4 shrink-0 text-muted-foreground" />
+          <span className="min-w-0">
+            <span className="block truncate text-sm font-semibold">{name}</span>
+            <span className="block truncate font-mono text-xs text-muted-foreground">{project.canonical}</span>
+          </span>
+          {project.vcs ? (
+            <Badge variant="outline" className="ml-1 hidden shrink-0 sm:inline-flex">
+              {project.vcs}
+            </Badge>
+          ) : null}
+        </button>
+        <Button
+          size="sm"
+          variant="outline"
+          onClick={handleNewSession}
+          disabled={createSession.isPending}
+          className="shrink-0"
+        >
+          {createSession.isPending ? <Loader2 className="mr-1 h-4 w-4 animate-spin" /> : <Plus className="mr-1 h-4 w-4" />}
+          New session
+        </Button>
+      </div>
+      {expanded ? <ProjectSessions serverId={serverId} directory={project.canonical} /> : null}
+    </Card>
+  )
+}
+
+function RemoteServerContent({ serverId }: { serverId: string }) {
+  const navigate = useNavigate()
+  const { servers, isLoading: serversLoading } = useOpenCodeServers()
+  const { statusById, isLoading: statusLoading } = useOpenCodeServerStatuses()
+  const { setActiveTab } = useSettingsDialog()
+  const createSession = useCreateSession()
+  const [openDirectory, setOpenDirectory] = useState('')
+
+  const server = servers.find((candidate) => candidate.id === serverId)
+  const status = statusById[serverId]
+  const isDisabled = server !== undefined && !server.enabled
+
+  const projectsQuery = useQuery({
+    queryKey: serverScopedKey(['opencode', 'projects'], serverId),
+    queryFn: () => listProjects(serverId),
+    enabled: server?.enabled === true,
+    retry: false,
+  })
+
+  const openSettings = () => setActiveTab('servers')
+
+  const handleOpenDirectory = async (event: FormEvent) => {
+    event.preventDefault()
+    const directory = openDirectory.trim()
+    if (!directory) return
+    try {
+      const session = await createSession.mutateAsync({ directory })
+      navigate(getServerSessionPath(serverId, session.id))
+    } catch {
+      return
+    }
+  }
+
+  return (
+    <div className="flex h-full max-h-full min-w-0 flex-col overflow-hidden bg-gradient-to-br from-background via-background to-background">
+      <Header>
+        <div className="flex min-w-0 flex-1 items-center gap-2">
+          <Header.BackButton to="/" />
+          <Header.Title>{server?.name ?? 'Linked server'}</Header.Title>
+          <span className="hidden min-w-0 truncate font-mono text-xs text-muted-foreground sm:block">
+            {server?.baseUrl}
+          </span>
+        </div>
+        <Header.Actions>
+          <ConnectionStatus status={status} isLoading={statusLoading && !status} />
+          <Button variant="outline" size="sm" onClick={openSettings}>
+            <Settings className="mr-1 h-4 w-4" />
+            <span className="hidden sm:inline">Manage servers</span>
+            <span className="sr-only sm:hidden">Manage servers</span>
+          </Button>
+        </Header.Actions>
+      </Header>
+
+      <div className="mx-auto flex w-full max-w-4xl flex-1 flex-col gap-4 overflow-y-auto p-3 pb-[calc(env(safe-area-inset-bottom)+60px)] sm:pb-4">
+        {!serversLoading && !server ? (
+          <Card className="flex flex-col items-center gap-3 p-6 text-center">
+            <Server className="h-8 w-8 text-muted-foreground" />
+            <div>
+              <p className="font-medium">Server not found</p>
+              <p className="text-sm text-muted-foreground">
+                This linked server is no longer configured.
+              </p>
+            </div>
+            <Button variant="outline" size="sm" onClick={openSettings}>
+              Open server settings
+            </Button>
+          </Card>
+        ) : null}
+
+        {isDisabled ? (
+          <Card className="flex flex-col items-center gap-3 p-6 text-center">
+            <Server className="h-8 w-8 text-muted-foreground" />
+            <div>
+              <p className="font-medium">This server is disabled</p>
+              <p className="text-sm text-muted-foreground">
+                Enable it in Settings → Servers to browse its projects and sessions.
+              </p>
+            </div>
+            <Button variant="outline" size="sm" onClick={openSettings}>
+              Open server settings
+            </Button>
+          </Card>
+        ) : null}
+
+        {server && !isDisabled && projectsQuery.isError ? (
+          <Card className="flex flex-col items-center gap-3 p-6 text-center">
+            <Server className="h-8 w-8 text-muted-foreground" />
+            <div>
+              <p className="font-medium">Could not load projects</p>
+              <p className="text-sm text-muted-foreground">
+                {projectsQuery.error instanceof Error
+                  ? projectsQuery.error.message
+                  : 'The server did not respond.'}
+              </p>
+            </div>
+            <Button variant="outline" size="sm" onClick={() => void projectsQuery.refetch()}>
+              Retry
+            </Button>
+          </Card>
+        ) : null}
+
+        {server && !isDisabled && !projectsQuery.isError ? (
+          <section aria-label="Projects" className="flex flex-col gap-2">
+            <div className="flex items-center justify-between">
+              <h2 className="text-xs font-medium uppercase tracking-wider text-muted-foreground">Projects</h2>
+              {projectsQuery.isFetching ? (
+                <span className="flex items-center gap-1 text-xs text-muted-foreground">
+                  <Loader2 className="h-3 w-3 animate-spin" />
+                  Refreshing
+                </span>
+              ) : null}
+            </div>
+
+            {projectsQuery.isLoading ? (
+              <Card className="flex items-center gap-2 p-4 text-sm text-muted-foreground">
+                <Loader2 className="h-4 w-4 animate-spin" />
+                Loading projects...
+              </Card>
+            ) : (projectsQuery.data ?? []).length === 0 ? (
+              <Card className="flex flex-col items-center gap-2 p-6 text-center">
+                <FolderGit2 className="h-8 w-8 text-muted-foreground" />
+                <p className="font-medium">No projects on this server yet</p>
+                <p className="text-sm text-muted-foreground">
+                  Start a session in a directory below to create one.
+                </p>
+              </Card>
+            ) : (
+              (projectsQuery.data ?? []).map((project) => (
+                <ProjectRow key={project.id} project={project} serverId={serverId} />
+              ))
+            )}
+          </section>
+        ) : null}
+
+        {server && !isDisabled ? (
+          <section aria-label="Open directory" className="flex flex-col gap-2">
+            <h2 className="text-xs font-medium uppercase tracking-wider text-muted-foreground">Open directory</h2>
+            <form onSubmit={handleOpenDirectory} className="flex items-center gap-2">
+              <Input
+                value={openDirectory}
+                onChange={(event) => setOpenDirectory(event.target.value)}
+                placeholder="/absolute/path/on/the/server"
+                aria-label="Directory path"
+                autoComplete="off"
+                name="remote-directory"
+                className="font-mono text-sm"
+              />
+              <Button type="submit" disabled={!openDirectory.trim() || createSession.isPending} className="shrink-0">
+                {createSession.isPending ? (
+                  <Loader2 className="mr-1 h-4 w-4 animate-spin" />
+                ) : (
+                  <Plus className="mr-1 h-4 w-4" />
+                )}
+                Start session
+              </Button>
+            </form>
+          </section>
+        ) : null}
+      </div>
+    </div>
+  )
+}
+
+export function RemoteServer() {
+  const { serverId } = useParams<{ serverId: string }>()
+
+  if (!serverId) {
+    return null
+  }
+
+  return <RemoteServerContent serverId={serverId} />
+}
diff --git a/frontend/src/pages/SessionDetail.tsx b/frontend/src/pages/SessionDetail.tsx
index a4d88bbda..f23e0d4ed 100644
--- a/frontend/src/pages/SessionDetail.tsx
+++ b/frontend/src/pages/SessionDetail.tsx
@@ -10,7 +10,7 @@ import { SquareFill } from "@/components/ui/square-fill";
 import { Header } from "@/components/ui/header";
 import { Badge } from "@/components/ui/badge";
 import { SessionPickerDialog } from "@/components/session/SessionPickerDialog";
-import { getRepoPath, getSessionListPath, getSessionPath } from '@/lib/navigation'
+import { getRepoPath, getServerPath, getServerSessionPath, getSessionListPath, getSessionPath } from '@/lib/navigation'
 import { FetchError } from '@/api/fetchWrapper'
 
 import { FileBrowserSheet } from "@/components/file-browser/FileBrowserSheet";
@@ -40,14 +40,17 @@ import { getMessagesContentVersion } from "./sessionContentVersion";
 import { useSpeakVisibleMessages } from "@/hooks/useSpeakVisibleMessages";
 import { showToast } from "@/lib/toast";
 import { getWorkspaceFilePath } from "@/lib/markdownLinks";
-import { getRepoDisplayName } from "@/lib/utils";
+import { getRepoDisplayName, getDirectoryName } from "@/lib/utils";
 import { resolveSessionBranch } from "@/lib/activeWork";
 import { RepoMcpDialog } from "@/components/repo/RepoMcpDialog";
 import { ProjectActionsMenu } from "@/components/repo/ProjectActionsMenu";
 import { RepoActionsDialog } from "@/components/repo/RepoActionsDialog";
 import { ResetPermissionsDialog } from "@/components/repo/ResetPermissionsDialog";
 import { RepoSkillsDialog } from "@/components/repo/RepoSkillsDialog";
-import { compactSession, forkSession, listSessionMessages } from "@/api/opencode";
+import { compactSession, forkSession, listProjects, listSessionMessages } from "@/api/opencode";
+import { useOpenCodeServerId, isLocalOpenCodeServer } from "@/contexts/OpenCodeServerContext";
+import { useOpenCodeServers, useOpenCodeServerStatuses } from "@/hooks/useOpenCodeServers";
+import { serverScopedKey } from "@/lib/serverScope";
 import { useSessionStatus } from "@/stores/sessionStatusStore";
 import type { PageCommandActions } from "@/lib/builtinCommands";
 import { useRedoMessage, useUndoMessage } from "@/hooks/useUndoMessage";
@@ -89,14 +92,14 @@ function applyRevertBoundary(
   return messages.slice(0, revertIndex)
 }
 
-async function fetchCompleteSessionHistory(sessionID: string): Promise<SessionMessageInfo[]> {
+async function fetchCompleteSessionHistory(sessionID: string, serverId?: string): Promise<SessionMessageInfo[]> {
   let history: SessionMessageInfo[] = []
   const seenIds = new Set<string>()
   const seenCursors = new Set<string>()
   let cursor: string | undefined
 
   for (;;) {
-    const page = await listSessionMessages(sessionID, cursor === undefined ? {} : { cursor })
+    const page = await listSessionMessages(sessionID, cursor === undefined ? {} : { cursor }, serverId)
     const older = page.messages.filter((message) => !seenIds.has(message.id))
     for (const message of older) seenIds.add(message.id)
     history = [...older, ...history]
@@ -120,6 +123,8 @@ function SessionRouteFallback({ message, backTo, backLabel }: { message: string;
 }
 
 export function SessionDetail() {
+  const serverId = useOpenCodeServerId();
+  const isRemoteServer = !isLocalOpenCodeServer(serverId);
   const { id, sessionId } = useParams<{ id: string; sessionId: string }>();
   const navigate = useNavigate();
   const location = useLocation();
@@ -177,23 +182,41 @@ export function SessionDetail() {
   const { data: repo, isLoading: repoLoading } = useQuery({
     queryKey: ["repo", repoId],
     queryFn: () => getRepo(repoId),
-    enabled: id !== undefined,
+    enabled: id !== undefined && !isRemoteServer,
     retry: (failureCount, error) => !(error instanceof FetchError && error.statusCode === 404) && failureCount < 3,
   });
 
-  useRepoActivity(repoId, Boolean(repo));
+  useRepoActivity(repoId, Boolean(repo) && !isRemoteServer);
 
-  const sessionRouteSuffix = isAssistantSession ? '?assistant=1' : '';
+  const sessionRouteSuffix = isAssistantSession && !isRemoteServer ? '?assistant=1' : '';
 
   const repoDirectory = repo?.fullPath;
   const [resolvedSessionDirectory, setResolvedSessionDirectory] = useState<{ sessionId: string; directory: string } | null>(null);
-  const sessionDirectory = (
+  const resolvedDirectory = (
     resolvedSessionDirectory && resolvedSessionDirectory.sessionId === sessionId
       ? resolvedSessionDirectory.directory
       : undefined
-  ) ?? repoDirectory;
+  );
+  const sessionDirectory = isRemoteServer ? resolvedDirectory : resolvedDirectory ?? repoDirectory;
+
+  const { data: repoSiblings } = useRepoSiblings(!isAssistantSession && !isRemoteServer && repo && !repo.isWorktree ? repoId : undefined);
+
+  const { servers: linkedServers } = useOpenCodeServers({ enabled: isRemoteServer });
 
-  const { data: repoSiblings } = useRepoSiblings(!isAssistantSession && repo && !repo.isWorktree ? repoId : undefined);
+  const { data: remoteProjects } = useQuery({
+    queryKey: serverScopedKey(['opencode', 'projects'], serverId),
+    queryFn: () => listProjects(serverId),
+    enabled: isRemoteServer,
+    retry: false,
+  });
+
+  const remoteProjectDirectory = useMemo(() => {
+    if (!isRemoteServer || !sessionDirectory) return undefined;
+    const project = remoteProjects?.find(
+      (entry) => sessionDirectory === entry.canonical || sessionDirectory.startsWith(`${entry.canonical}/`),
+    );
+    return project?.canonical ?? sessionDirectory;
+  }, [isRemoteServer, remoteProjects, sessionDirectory]);
 
   const sessionBranch = useMemo(
     () => (repo && !isAssistantSession ? resolveSessionBranch(repo, sessionDirectory, repoSiblings) : null),
@@ -216,6 +239,10 @@ export function SessionDetail() {
   }, [sessionId, session?.location.directory]);
 
   const { isConnected, isReconnecting } = useSSE(sessionDirectory, sessionId);
+  const { statusById } = useOpenCodeServerStatuses({ enabled: isRemoteServer });
+  const remoteServerConnected = statusById[serverId]?.connected === true;
+  const streamConnected = isRemoteServer ? isConnected && remoteServerConnected : isConnected;
+  const streamReconnecting = isRemoteServer ? isReconnecting || !remoteServerConnected : isReconnecting;
 
   const {
     messages: transcriptMessages,
@@ -241,7 +268,7 @@ export function SessionDetail() {
     let cancelled = false;
     setForkPickerLoading(true);
     setForkPickerMessages(null);
-    fetchCompleteSessionHistory(sessionId)
+    fetchCompleteSessionHistory(sessionId, serverId)
       .then((history) => {
         if (cancelled) return;
         setForkPickerMessages(applyRevertBoundary(history, revertMessageID));
@@ -258,7 +285,7 @@ export function SessionDetail() {
     return () => {
       cancelled = true;
     };
-  }, [messagePickerMode, sessionId, revertMessageID]);
+  }, [messagePickerMode, sessionId, revertMessageID, serverId]);
 
   const messagesContentVersion = useMemo(() => getMessagesContentVersion(messages), [messages]);
 
@@ -332,7 +359,7 @@ export function SessionDetail() {
   useAutoOpenWalkthrough({
     sessionId,
     messages,
-    enabled: docked,
+    enabled: docked && !isRemoteServer,
     loading: messagesLoading,
     onOpen: handleShowWalkthrough,
   });
@@ -358,13 +385,13 @@ export function SessionDetail() {
   const syncPendingActionsForSession = useCallback(async () => {
     if (!sessionDirectory || !sessionId) return
     await Promise.all([
-      syncPermissionsForSession(sessionDirectory, sessionId),
-      syncFormsForSession(sessionDirectory, sessionId),
+      syncPermissionsForSession(sessionDirectory, sessionId, serverId),
+      syncFormsForSession(sessionDirectory, sessionId, serverId),
     ])
-  }, [sessionDirectory, sessionId, syncPermissionsForSession, syncFormsForSession])
+  }, [sessionDirectory, sessionId, serverId, syncPermissionsForSession, syncFormsForSession])
 
   useQuery({
-    queryKey: ['opencode', 'pending-actions', sessionId, sessionDirectory],
+    queryKey: serverScopedKey(['opencode', 'pending-actions', sessionId, sessionDirectory], serverId),
     queryFn: async () => {
       await syncPendingActionsForSession()
       return null
@@ -381,12 +408,12 @@ export function SessionDetail() {
     try {
       const newSession = await createSessionAsync({ agent: undefined });
       if (newSession?.id) {
-        navigate(`/repos/${repoId}/sessions/${newSession.id}${sessionRouteSuffix}`);
+        navigate(getSessionPath(repoId, newSession.id, { serverId }));
       }
     } catch {
       showToast.error('Failed to create new session');
     }
-  }, [createSessionAsync, navigate, repoId, sessionRouteSuffix]);
+  }, [createSessionAsync, navigate, repoId, serverId]);
 
   const { mutateAsync: undoMessageAsync } = useUndoMessage({
     sessionId: sessionId ?? '',
@@ -406,13 +433,13 @@ export function SessionDetail() {
     setSessionStatus(sessionId, { type: 'compact' });
 
     try {
-      await compactSession(sessionId);
+      await compactSession(sessionId, serverId);
       showToast.success('Compaction requested', { id: toastId });
     } catch (error) {
       showToast.error(`Compact failed: ${error instanceof Error ? error.message : 'Unknown error'}`, { id: toastId });
       setSessionStatus(sessionId, { type: 'idle' });
     }
-  }, [sessionId, setSessionStatus]);
+  }, [sessionId, serverId, setSessionStatus]);
 
   const handleUndo = useCallback(async () => {
     if (!sessionId) return;
@@ -442,10 +469,10 @@ export function SessionDetail() {
   const handleForkAtMessage = useCallback(async (messageID?: string) => {
     if (!sessionId) return;
     try {
-      const forkedSession = await forkSession(sessionId, messageID);
+      const forkedSession = await forkSession(sessionId, messageID, serverId);
       if (forkedSession?.id) {
         setMessagePickerMode(null);
-        navigate(`/repos/${repoId}/sessions/${forkedSession.id}${sessionRouteSuffix}`);
+        navigate(getSessionPath(repoId, forkedSession.id, { serverId }));
         if (messageID) {
           const chosenMessage = forkPickerMessages?.find((message) => message.id === messageID);
           if (chosenMessage?.type === 'user') {
@@ -457,7 +484,7 @@ export function SessionDetail() {
     } catch (error) {
       showToast.error(`Fork failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
-  }, [sessionId, forkPickerMessages, navigate, repoId, sessionRouteSuffix]);
+  }, [sessionId, forkPickerMessages, navigate, repoId, serverId]);
 
   const openTimelinePicker = useCallback(() => setMessagePickerMode('timeline'), []);
 
@@ -473,9 +500,13 @@ export function SessionDetail() {
   }, []);
 
   const handleCloseSession = useCallback(() => {
+    if (isRemoteServer) {
+      navigate(getServerPath(serverId))
+      return
+    }
     const tab = new URLSearchParams(location.search).get('repoTab') ?? undefined;
     navigate(getSessionListPath(repoId, isAssistantSession, tab))
-  }, [navigate, repoId, isAssistantSession, location.search])
+  }, [navigate, repoId, isAssistantSession, isRemoteServer, serverId, location.search])
 
   const handleOpenModelDialog = useCallback(() => {
     promptInputRef.current?.openModelPicker();
@@ -517,14 +548,14 @@ export function SessionDetail() {
   }, [filesVisible]);
 
   const handleChildSessionClick = useCallback((childSessionId: string) => {
-    navigate(`/repos/${repoId}/sessions/${childSessionId}${sessionRouteSuffix}`)
-  }, [navigate, repoId, sessionRouteSuffix]);
+    navigate(getSessionPath(repoId, childSessionId, { serverId }))
+  }, [navigate, repoId, serverId]);
 
   const handleParentSessionClick = useCallback(() => {
     if (session?.parentID) {
-      navigate(`/repos/${repoId}/sessions/${session.parentID}${sessionRouteSuffix}`)
+      navigate(getSessionPath(repoId, session.parentID, { serverId }))
     }
-  }, [navigate, repoId, session?.parentID, sessionRouteSuffix]);
+  }, [navigate, repoId, session?.parentID, serverId]);
 
   const handleToggleDetails = useCallback(() => {
     const newValue = !preferences?.expandToolCalls
@@ -536,12 +567,12 @@ export function SessionDetail() {
     if (!session || !sessionId) {
       throw new Error('No session data to export')
     }
-    const history = await fetchCompleteSessionHistory(sessionId)
+    const history = await fetchCompleteSessionHistory(sessionId, serverId)
     return exportSession(
       applyRevertBoundary(history, session.revert?.messageID),
       session,
     )
-  }, [session, sessionId]);
+  }, [session, sessionId, serverId]);
 
   const handleExportSession = useCallback(async () => {
     const result = await buildSessionExport().catch((error: unknown) => {
@@ -665,7 +696,7 @@ export function SessionDetail() {
     return <Navigate to="/" replace />;
   }
 
-  if (!isAssistantSession && repoLoading) {
+  if (!isAssistantSession && !isRemoteServer && repoLoading) {
     return (
       <div className="flex items-center justify-center min-h-screen bg-gradient-to-br from-background via-background to-background">
         <div className="flex flex-col items-center gap-2">
@@ -676,7 +707,7 @@ export function SessionDetail() {
     );
   }
 
-  if (!isAssistantSession && !repo) {
+  if (!isAssistantSession && !isRemoteServer && !repo) {
     return <SessionRouteFallback message="Repository not found" backTo="/" backLabel="Back to repositories" />;
   }
 
@@ -685,17 +716,47 @@ export function SessionDetail() {
     return (
       <SessionRouteFallback
         message="Session not found"
-        backTo={getSessionListPath(repoId, isAssistantSession, listTab)}
-        backLabel="Back to sessions"
+        backTo={isRemoteServer ? getServerPath(serverId) : getSessionListPath(repoId, isAssistantSession, listTab)}
+        backLabel={isRemoteServer ? 'Back to server' : 'Back to sessions'}
       />
     );
   }
 
-  const workspaceDisplayName = isAssistantSession || !repo
-    ? 'Assistant'
-    : getRepoDisplayName(repo);
+  if (isRemoteServer) {
+    if (sessionQueryError) {
+      return (
+        <SessionRouteFallback
+          message="Failed to load session"
+          backTo={getServerPath(serverId)}
+          backLabel="Back to server"
+        />
+      );
+    }
+
+    if (sessionLoading || !sessionDirectory) {
+      return (
+        <div className="flex items-center justify-center min-h-screen bg-gradient-to-br from-background via-background to-background">
+          <div className="flex flex-col items-center gap-2">
+            <div className="w-8 h-8 animate-spin rounded-full border-2 border-muted border-t-foreground" />
+            <span className="text-muted-foreground">Loading session...</span>
+          </div>
+        </div>
+      );
+    }
+  }
+
+  const linkedServer = linkedServers.find((candidate) => candidate.id === serverId);
+  const workspaceDisplayName = isRemoteServer
+    ? [linkedServer?.name ?? 'Linked server', sessionDirectory ? getDirectoryName(sessionDirectory) : undefined]
+        .filter(Boolean)
+        .join(' · ')
+    : isAssistantSession || !repo
+      ? 'Assistant'
+      : getRepoDisplayName(repo);
   const tabFromUrl = new URLSearchParams(location.search).get('repoTab') ?? undefined;
-  const sessionBackPath = getSessionListPath(repoId, isAssistantSession, tabFromUrl);
+  const sessionBackPath = isRemoteServer
+    ? getServerPath(serverId)
+    : getSessionListPath(repoId, isAssistantSession, tabFromUrl);
 
   return (
     <div
@@ -750,19 +811,19 @@ export function SessionDetail() {
           </div>
           <Header.Actions className="gap-2 sm:gap-4">
             <div className="flex items-center gap-1">
-              {!isAssistantSession && (
+              {!isAssistantSession && !isRemoteServer && (
                 <ProjectActionsMenu repoId={repoId} directory={sessionDirectory} />
               )}
-              <PendingActionsGroup />
+              <PendingActionsGroup showScheduleReports={!isRemoteServer} />
             </div>
             <ContextUsageIndicator
               directory={sessionDirectory}
               sessionID={sessionId}
-              isConnected={isConnected}
-              isReconnecting={isReconnecting}
+              isConnected={streamConnected}
+              isReconnecting={streamReconnecting}
               revertMessageID={revertMessageID}
             />
-            <SessionMoreButton />
+            {!isRemoteServer && <SessionMoreButton />}
           </Header.Actions>
         </Header>
 
@@ -782,9 +843,9 @@ export function SessionDetail() {
               messages={messages}
               pending={pendingPrompts}
               isSessionBusy={isSessionActive}
-              onFileClick={handleFileClick}
+              onFileClick={isRemoteServer ? undefined : handleFileClick}
               onChildSessionClick={handleChildSessionClick}
-              onOpenWalkthrough={handleShowWalkthrough}
+              onOpenWalkthrough={isRemoteServer ? undefined : handleShowWalkthrough}
               onUndoMessage={handleUndoMessage}
               model={modelRef ? formatOpenCodeModelRef(modelRef) : undefined}
             />
@@ -849,8 +910,8 @@ export function SessionDetail() {
                   onMinimize={() => handleMinimizeForm(currentForm)}
                 />
               )}
-              <SessionSendErrorBanner sessionId={sessionId} isConnected={isConnected} isReconnecting={isReconnecting} />
-              <SessionGoalBar sessionID={sessionId} />
+              <SessionSendErrorBanner sessionId={sessionId} isConnected={streamConnected} isReconnecting={streamReconnecting} />
+              {!isRemoteServer && <SessionGoalBar sessionID={sessionId} />}
               <BackgroundWorkBar
                 sessionID={sessionId}
                 directory={sessionDirectory}
@@ -882,7 +943,7 @@ export function SessionDetail() {
           filesBasePath={workspaceBasePath}
           currentBranch={repo?.currentBranch || repo?.branch || "main"}
           selectedFilePath={selectedFilePath}
-          repoDirectory={repoDirectory}
+          repoDirectory={isRemoteServer ? sessionDirectory : repoDirectory}
           onSkillLoaded={handleSkillLoaded}
           walkthroughSourceRequest={walkthroughSourceRequest}
           walkthroughModel={modelRef}
@@ -895,16 +956,25 @@ export function SessionDetail() {
       <SessionPickerDialog
         open={sessionsDialogOpen}
         onOpenChange={setSessionsDialogOpen}
-        currentRepo={repo}
+        currentRepo={isRemoteServer ? undefined : repo}
         activeSessionID={sessionId || undefined}
+        remote={
+          isRemoteServer
+            ? { serverId, serverName: linkedServer?.name, projectDirectory: remoteProjectDirectory }
+            : undefined
+        }
         onSelectSession={(session, sessionRepo) => {
-          if (sessionRepo.id === repoId) {
+          if (!isRemoteServer && sessionRepo.id === repoId) {
             navigate(`/repos/${repoId}/sessions/${session.id}${sessionRouteSuffix}`)
           } else {
             navigate(getSessionPath(sessionRepo.id, session.id))
           }
           setSessionsDialogOpen(false)
         }}
+        onSelectRemoteSession={(session, targetServerId) => {
+          navigate(getServerSessionPath(targetServerId, session.id))
+          setSessionsDialogOpen(false)
+        }}
         onDeleteActiveSession={() => {
           setSessionsDialogOpen(false)
           handleCloseSession()
@@ -941,14 +1011,16 @@ export function SessionDetail() {
         />
       )}
 
-      <FileBrowserSheet
-        isOpen={!docked && fileBrowserOpen}
-        onClose={handleFileBrowserClose}
-        basePath={workspaceBasePath}
-        repoName={workspaceDisplayName}
-        repoId={repoId}
-        initialSelectedFile={selectedFilePath}
-      />
+      {!isRemoteServer && (
+        <FileBrowserSheet
+          isOpen={!docked && fileBrowserOpen}
+          onClose={handleFileBrowserClose}
+          basePath={workspaceBasePath}
+          repoName={workspaceDisplayName}
+          repoId={repoId}
+          initialSelectedFile={selectedFilePath}
+        />
+      )}
 
       {sessionId && (
         <RepoSkillsDialog
@@ -956,12 +1028,12 @@ export function SessionDetail() {
           onOpenChange={setSkillsDialogOpen}
           repoId={repoId}
           sessionId={sessionId}
-          directory={repoDirectory}
+          directory={isRemoteServer ? sessionDirectory : repoDirectory}
           onSkillLoaded={handleSkillLoaded}
         />
       )}
 
-      {sessionId && (
+      {!isRemoteServer && sessionId && (
         <ChangesWalkthroughSheet
           sessionId={sessionId}
           open={!docked && walkthroughOpen}
@@ -975,10 +1047,10 @@ export function SessionDetail() {
       <RepoMcpDialog
         open={!docked && mcpDialogOpen}
         onOpenChange={setMcpDialogOpen}
-        directory={repoDirectory}
+        directory={isRemoteServer ? sessionDirectory : repoDirectory}
       />
 
-      {!isAssistantSession && (
+      {!isAssistantSession && !isRemoteServer && (
         <RepoActionsDialog
           repoId={repoId}
           directory={sessionDirectory}
@@ -987,32 +1059,40 @@ export function SessionDetail() {
         />
       )}
 
-      <SourceControlPanel
-        repoId={repoId}
-        isOpen={!docked && sourceControlOpen}
-        onClose={() => setSourceControlOpen(false)}
-        currentBranch={repo?.currentBranch || repo?.branch || "main"}
-        repoName={workspaceDisplayName}
-      />
+      {!isRemoteServer && (
+        <SourceControlPanel
+          repoId={repoId}
+          isOpen={!docked && sourceControlOpen}
+          onClose={() => setSourceControlOpen(false)}
+          currentBranch={repo?.currentBranch || repo?.branch || "main"}
+          repoName={workspaceDisplayName}
+        />
+      )}
 
-      <TerminalPanel
-        repoId={repoId}
-        directory={sessionDirectory}
-        isOpen={!docked && terminalOpen}
-        onClose={() => setTerminalOpen(false)}
-      />
+      {!isRemoteServer && (
+        <TerminalPanel
+          repoId={repoId}
+          directory={sessionDirectory}
+          isOpen={!docked && terminalOpen}
+          onClose={() => setTerminalOpen(false)}
+        />
+      )}
 
-      <PreviewPanel
-        isOpen={!docked && previewOpen}
-        onClose={() => setPreviewOpen(false)}
-        directory={sessionDirectory}
-      />
+      {!isRemoteServer && (
+        <PreviewPanel
+          isOpen={!docked && previewOpen}
+          onClose={() => setPreviewOpen(false)}
+          directory={sessionDirectory}
+        />
+      )}
 
-      <ResetPermissionsDialog
-        open={resetPermissionsOpen}
-        onOpenChange={setResetPermissionsOpen}
-        repoId={repoId}
-      />
+      {!isRemoteServer && (
+        <ResetPermissionsDialog
+          open={resetPermissionsOpen}
+          onOpenChange={setResetPermissionsOpen}
+          repoId={repoId}
+        />
+      )}
     </div>
   );
 }
diff --git a/frontend/src/pages/__tests__/RemoteServer.test.tsx b/frontend/src/pages/__tests__/RemoteServer.test.tsx
new file mode 100644
index 000000000..3689be291
--- /dev/null
+++ b/frontend/src/pages/__tests__/RemoteServer.test.tsx
@@ -0,0 +1,218 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { render, screen, waitFor, fireEvent } from '@testing-library/react'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { MemoryRouter, Route, Routes } from 'react-router-dom'
+import { RemoteServer } from '../RemoteServer'
+
+const mocks = vi.hoisted(() => ({
+  listProjects: vi.fn(),
+  useSessionsAcrossDirectories: vi.fn(),
+  useCreateSession: vi.fn(),
+  useOpenCodeServers: vi.fn(),
+  useOpenCodeServerStatuses: vi.fn(),
+  useSettingsDialog: vi.fn(),
+  useSSE: vi.fn(),
+  setActiveTab: vi.fn(),
+  createSession: vi.fn(),
+}))
+
+vi.mock('@/api/opencode', () => ({
+  listProjects: mocks.listProjects,
+}))
+
+vi.mock('@/hooks/useOpenCode', () => ({
+  useSessionsAcrossDirectories: mocks.useSessionsAcrossDirectories,
+  useCreateSession: mocks.useCreateSession,
+}))
+
+vi.mock('@/hooks/useOpenCodeServers', () => ({
+  useOpenCodeServers: mocks.useOpenCodeServers,
+  useOpenCodeServerStatuses: mocks.useOpenCodeServerStatuses,
+}))
+
+vi.mock('@/hooks/useSettingsDialog', () => ({
+  useSettingsDialog: mocks.useSettingsDialog,
+}))
+
+vi.mock('@/hooks/useSSE', () => ({
+  useSSE: mocks.useSSE,
+}))
+
+const server = {
+  id: 'srv_kitchen',
+  name: 'Kitchen',
+  baseUrl: 'https://kitchen.example.com',
+  username: 'opencode',
+  enabled: true,
+  hasPassword: true,
+  createdAt: 1,
+  updatedAt: 2,
+}
+
+const project = {
+  id: 'prj_1',
+  canonical: '/home/me/app',
+  name: 'App',
+  time: { created: 1, updated: 2, active: 2 },
+  sandboxes: [],
+}
+
+const session = {
+  id: 'ses_1',
+  projectID: 'prj_1',
+  title: 'Fix the bug',
+  time: { created: 1, updated: Date.now() - 60000 },
+  location: { directory: '/home/me/app' },
+}
+
+function createQueryClient() {
+  return new QueryClient({ defaultOptions: { queries: { retry: false } } })
+}
+
+function renderServer(serverId = 'srv_kitchen') {
+  return render(
+    <QueryClientProvider client={createQueryClient()}>
+      <MemoryRouter initialEntries={[`/servers/${serverId}`]}>
+        <Routes>
+          <Route path="/servers/:serverId" element={<RemoteServer />} />
+          <Route path="/servers/:serverId/sessions/:sessionId" element={<div data-testid="session-route" />} />
+        </Routes>
+      </MemoryRouter>
+    </QueryClientProvider>,
+  )
+}
+
+describe('RemoteServer', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mocks.listProjects.mockResolvedValue([project])
+    mocks.useSessionsAcrossDirectories.mockReturnValue({ data: [session], isLoading: false })
+    mocks.useCreateSession.mockReturnValue({ mutateAsync: mocks.createSession, isPending: false })
+    mocks.useOpenCodeServers.mockReturnValue({ servers: [server], isLoading: false })
+    mocks.useOpenCodeServerStatuses.mockReturnValue({
+      statuses: [],
+      statusById: {
+        srv_kitchen: {
+          serverId: 'srv_kitchen',
+          connected: true,
+          version: '2.0.15',
+          error: null,
+        },
+      },
+      isLoading: false,
+    })
+    mocks.useSettingsDialog.mockReturnValue({ setActiveTab: mocks.setActiveTab })
+    mocks.useSSE.mockReturnValue({ isConnected: true, isReconnecting: false })
+  })
+
+  it('renders the server identity and connection status', async () => {
+    renderServer()
+
+    expect(screen.getByText('Kitchen')).toBeInTheDocument()
+    expect(screen.getByText('https://kitchen.example.com')).toBeInTheDocument()
+    await waitFor(() => {
+      expect(screen.getByText(/Connected/)).toBeInTheDocument()
+    })
+    expect(screen.getByText(/v2\.0\.15/)).toBeInTheDocument()
+  })
+
+  it('lists projects from the remote server', async () => {
+    renderServer()
+
+    await waitFor(() => {
+      expect(screen.getByText('App')).toBeInTheDocument()
+    })
+    expect(screen.getByText('/home/me/app')).toBeInTheDocument()
+    expect(mocks.listProjects).toHaveBeenCalledWith('srv_kitchen')
+  })
+
+  it('links each expanded project session to the remote session route', async () => {
+    renderServer()
+
+    fireEvent.click(await screen.findByRole('button', { name: /App/ }))
+
+    const link = await screen.findByRole('link', { name: /Fix the bug/ })
+    expect(link).toHaveAttribute('href', '/servers/srv_kitchen/sessions/ses_1')
+    expect(mocks.useSessionsAcrossDirectories).toHaveBeenCalledWith(['/home/me/app'])
+  })
+
+  it('creates a session in a project directory and navigates to it', async () => {
+    mocks.createSession.mockResolvedValue({ id: 'ses_new' })
+    renderServer()
+
+    await screen.findByText('App')
+    fireEvent.click(screen.getByRole('button', { name: /New session/ }))
+
+    await waitFor(() => {
+      expect(mocks.createSession).toHaveBeenCalledWith({ agent: undefined })
+    })
+    await waitFor(() => {
+      expect(screen.getByTestId('session-route')).toBeInTheDocument()
+    })
+  })
+
+  it('opens a session in an arbitrary directory', async () => {
+    mocks.createSession.mockResolvedValue({ id: 'ses_other' })
+    renderServer()
+
+    fireEvent.change(screen.getByLabelText('Directory path'), { target: { value: '/srv/other' } })
+    fireEvent.click(screen.getByRole('button', { name: /Start session/ }))
+
+    await waitFor(() => {
+      expect(mocks.createSession).toHaveBeenCalledWith({ directory: '/srv/other' })
+    })
+    await waitFor(() => {
+      expect(screen.getByTestId('session-route')).toBeInTheDocument()
+    })
+  })
+
+  it('shows the disabled state without loading projects', async () => {
+    mocks.useOpenCodeServers.mockReturnValue({
+      servers: [{ ...server, enabled: false }],
+      isLoading: false,
+    })
+
+    renderServer()
+
+    expect(screen.getByText('This server is disabled')).toBeInTheDocument()
+    expect(mocks.listProjects).not.toHaveBeenCalled()
+  })
+
+  it('shows an empty state when the server has no projects', async () => {
+    mocks.listProjects.mockResolvedValue([])
+
+    renderServer()
+
+    await waitFor(() => {
+      expect(screen.getByText('No projects on this server yet')).toBeInTheDocument()
+    })
+  })
+
+  it('shows the unreachable state from the status hook', async () => {
+    mocks.useOpenCodeServerStatuses.mockReturnValue({
+      statuses: [],
+      statusById: {
+        srv_kitchen: {
+          serverId: 'srv_kitchen',
+          connected: false,
+          version: null,
+          error: 'connection refused',
+        },
+      },
+      isLoading: false,
+    })
+
+    renderServer()
+
+    expect(screen.getByText('Unreachable')).toBeInTheDocument()
+    expect(screen.getByText(/connection refused/)).toBeInTheDocument()
+  })
+
+  it('opens the servers settings tab from the header', () => {
+    renderServer()
+
+    fireEvent.click(screen.getByRole('button', { name: /Manage servers/ }))
+
+    expect(mocks.setActiveTab).toHaveBeenCalledWith('servers')
+  })
+})
diff --git a/frontend/src/pages/__tests__/SessionDetail.commands.test.tsx b/frontend/src/pages/__tests__/SessionDetail.commands.test.tsx
index 18695e3e3..caf887a6a 100644
--- a/frontend/src/pages/__tests__/SessionDetail.commands.test.tsx
+++ b/frontend/src/pages/__tests__/SessionDetail.commands.test.tsx
@@ -361,7 +361,7 @@ describe('SessionDetail command actions', () => {
     })
 
     expect(mocks.setStatus).toHaveBeenCalledWith(SESSION_ID, { type: 'compact' })
-    expect(mocks.compactSession).toHaveBeenCalledWith(SESSION_ID)
+    expect(mocks.compactSession).toHaveBeenCalledWith(SESSION_ID, 'local')
     expect(mocks.showToast.loading).toHaveBeenCalledWith('Compacting session...', { id: `compact-${SESSION_ID}` })
     expect(mocks.showToast.success).toHaveBeenCalledWith('Compaction requested', { id: `compact-${SESSION_ID}` })
   })
@@ -444,8 +444,8 @@ describe('SessionDetail command actions', () => {
       await copyTranscript()
     })
 
-    expect(mocks.listSessionMessages).toHaveBeenCalledWith(SESSION_ID, {})
-    expect(mocks.listSessionMessages).toHaveBeenCalledWith(SESSION_ID, { cursor: 'cursor-1' })
+    expect(mocks.listSessionMessages).toHaveBeenCalledWith(SESSION_ID, {}, 'local')
+    expect(mocks.listSessionMessages).toHaveBeenCalledWith(SESSION_ID, { cursor: 'cursor-1' }, 'local')
     expect(mocks.copyTextToClipboard).toHaveBeenCalledTimes(1)
 
     const content = await (mocks.copyTextToClipboard.mock.calls[0][0] as Promise<string>)
@@ -525,7 +525,7 @@ describe('SessionDetail command actions', () => {
     })
 
     expect(await screen.findByText('history-only prompt')).toBeInTheDocument()
-    expect(mocks.listSessionMessages).toHaveBeenCalledWith(SESSION_ID, {})
+    expect(mocks.listSessionMessages).toHaveBeenCalledWith(SESSION_ID, {}, 'local')
   })
 
   it('forks before the chosen message and pre-fills the composer', async () => {
@@ -550,7 +550,7 @@ describe('SessionDetail command actions', () => {
 
     fireEvent.click(await screen.findByText('second prompt'))
 
-    await waitFor(() => expect(mocks.forkSession).toHaveBeenCalledWith(SESSION_ID, '2'))
+    await waitFor(() => expect(mocks.forkSession).toHaveBeenCalledWith(SESSION_ID, '2', 'local'))
     expect(mocks.setPromptValue).toHaveBeenCalledWith('second prompt')
     await waitFor(() => expect(captured.pathname.current).toBe('/repos/1/sessions/session-2'))
     expect(mocks.showToast.success).toHaveBeenCalledWith('Session forked')
@@ -574,7 +574,7 @@ describe('SessionDetail command actions', () => {
 
     fireEvent.click(await screen.findByText('history-only prompt'))
 
-    await waitFor(() => expect(mocks.forkSession).toHaveBeenCalledWith(SESSION_ID, '2'))
+    await waitFor(() => expect(mocks.forkSession).toHaveBeenCalledWith(SESSION_ID, '2', 'local'))
     expect(mocks.setPromptValue).toHaveBeenCalledWith('history-only prompt')
   })
 
@@ -590,7 +590,7 @@ describe('SessionDetail command actions', () => {
 
     fireEvent.click(await screen.findByText('Entire conversation'))
 
-    await waitFor(() => expect(mocks.forkSession).toHaveBeenCalledWith(SESSION_ID, undefined))
+    await waitFor(() => expect(mocks.forkSession).toHaveBeenCalledWith(SESSION_ID, undefined, 'local'))
     expect(mocks.setPromptValue).not.toHaveBeenCalled()
   })
 
@@ -764,8 +764,8 @@ describe('SessionDetail command actions', () => {
       await handler()
     })
 
-    expect(mocks.listSessionMessages).toHaveBeenCalledWith(SESSION_ID, {})
-    expect(mocks.listSessionMessages).toHaveBeenCalledWith(SESSION_ID, { cursor: 'cursor-1' })
+    expect(mocks.listSessionMessages).toHaveBeenCalledWith(SESSION_ID, {}, 'local')
+    expect(mocks.listSessionMessages).toHaveBeenCalledWith(SESSION_ID, { cursor: 'cursor-1' }, 'local')
     expect(mocks.downloadMarkdown).toHaveBeenCalledTimes(1)
 
     const content = mocks.downloadMarkdown.mock.calls[0][0] as string
diff --git a/frontend/src/pages/__tests__/SessionDetail.remote.test.tsx b/frontend/src/pages/__tests__/SessionDetail.remote.test.tsx
new file mode 100644
index 000000000..0217ffd8a
--- /dev/null
+++ b/frontend/src/pages/__tests__/SessionDetail.remote.test.tsx
@@ -0,0 +1,450 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { render, screen, waitFor, act } from '@testing-library/react'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { MemoryRouter, Route, Routes } from 'react-router-dom'
+import { OpenCodeServerProvider } from '@/contexts/OpenCodeServerContext'
+import { LocationCatcher } from '@/test/test-utils'
+import { MessageThread } from '@/components/message/MessageThread'
+import { ContextUsageIndicator } from '@/components/session/ContextUsageIndicator'
+import { SessionSendErrorBanner } from '@/components/session/SessionSendErrorBanner'
+import { PendingActionsGroup } from '@/components/notifications/PendingActionsGroup'
+import { SessionDetail } from '../SessionDetail'
+
+const mocks = vi.hoisted(() => ({
+  useSession: vi.fn(),
+  useSessionTranscript: vi.fn(),
+  useSSE: vi.fn(),
+  useRepoActivity: vi.fn(),
+  useRepoSiblings: vi.fn(),
+  usePermissions: vi.fn(),
+  useForms: vi.fn(),
+  useSettings: vi.fn(),
+  useSettingsDialog: vi.fn(),
+  useMobile: vi.fn(),
+  useVisualViewport: vi.fn(),
+  useShortcutActions: vi.fn(),
+  useAutoScroll: vi.fn(),
+  useDialogParam: vi.fn(),
+  useTerminalDialogParam: vi.fn(),
+  useOpenCodeServers: vi.fn(),
+  useOpenCodeServerStatuses: vi.fn(),
+  getRepo: vi.fn(),
+  useSessionStatus: vi.fn(),
+  SourceControlPanel: vi.fn(() => null),
+  TerminalPanel: vi.fn(() => null),
+  PreviewPanel: vi.fn(() => null),
+  FileBrowserSheet: vi.fn(() => null),
+  ProjectActionsMenu: vi.fn(() => null),
+  RepoActionsDialog: vi.fn(() => null),
+  ResetPermissionsDialog: vi.fn(() => null),
+  RepoSkillsDialog: vi.fn(() => null),
+  RepoMcpDialog: vi.fn(() => null),
+  ChangesWalkthroughSheet: vi.fn(() => null),
+  ToolSidePanel: vi.fn(() => null),
+  SessionGoalBar: vi.fn(() => null),
+  SessionPickerDialog: vi.fn(() => null),
+  SessionMoreButton: vi.fn(() => null),
+}))
+
+vi.mock('@/api/repos', () => ({ getRepo: mocks.getRepo }))
+
+vi.mock('@/hooks/useOpenCode', () => ({
+  useSession: mocks.useSession,
+  useInterruptSession: vi.fn(() => ({ mutate: vi.fn() })),
+  useUpdateSession: vi.fn(() => ({ mutate: vi.fn(), mutateAsync: vi.fn() })),
+  useCreateSession: vi.fn(() => ({ mutateAsync: vi.fn() })),
+}))
+
+vi.mock('@/hooks/useSessionTranscript', () => ({
+  useSessionTranscript: mocks.useSessionTranscript,
+}))
+
+vi.mock('@/hooks/useRepoSiblings', () => ({ useRepoSiblings: mocks.useRepoSiblings }))
+vi.mock('@/hooks/useRepoActivity', () => ({ useRepoActivity: mocks.useRepoActivity }))
+vi.mock('@/hooks/useSSE', () => ({ useSSE: mocks.useSSE }))
+
+vi.mock('@/hooks/useOpenCodeServers', () => ({
+  useOpenCodeServers: mocks.useOpenCodeServers,
+  useOpenCodeServerStatuses: mocks.useOpenCodeServerStatuses,
+}))
+
+vi.mock('@/hooks/useModelSelection', () => ({
+  useModelSelection: vi.fn(() => ({ model: null, modelString: null, modelRef: null })),
+}))
+
+vi.mock('@/hooks/useTTS', () => ({
+  useTTS: vi.fn(() => ({ isEnabled: false })),
+}))
+
+vi.mock('@/hooks/useSettings', () => ({ useSettings: mocks.useSettings }))
+vi.mock('@/hooks/useSettingsDialog', () => ({ useSettingsDialog: mocks.useSettingsDialog }))
+vi.mock('@/hooks/useMobile', () => ({
+  useMobile: mocks.useMobile,
+  useSwipeBack: vi.fn(() => ({ ref: vi.fn() })),
+}))
+vi.mock('@/hooks/useVisualViewport', () => ({ useVisualViewport: mocks.useVisualViewport }))
+vi.mock('@/contexts/KeyboardShortcutsContext', () => ({ useShortcutActions: mocks.useShortcutActions }))
+vi.mock('@/hooks/useAutoScroll', () => ({ useAutoScroll: mocks.useAutoScroll }))
+
+vi.mock('@/hooks/useDialogParam', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@/hooks/useDialogParam')>()
+  return { ...actual, useDialogParam: mocks.useDialogParam }
+})
+
+vi.mock('@/hooks/useOpenTerminal', () => ({
+  useTerminalDialogParam: mocks.useTerminalDialogParam,
+}))
+
+vi.mock('@/hooks/useAutoPlayLastResponse', () => ({
+  getAssistantText: vi.fn(() => ''),
+  getLatestPlayableAssistantMessage: vi.fn(() => null),
+  useAutoPlayLastResponse: vi.fn(() => {}),
+}))
+
+vi.mock('@/hooks/useAutoOpenWalkthrough', () => ({ useAutoOpenWalkthrough: vi.fn(() => {}) }))
+vi.mock('@/hooks/useSpeakVisibleMessages', () => ({ useSpeakVisibleMessages: vi.fn(() => vi.fn()) }))
+vi.mock('@/hooks/useUndoMessage', () => ({
+  useUndoMessage: vi.fn(() => ({ mutateAsync: vi.fn() })),
+  useRedoMessage: vi.fn(() => ({ mutateAsync: vi.fn() })),
+}))
+vi.mock('@/lib/toast', () => ({
+  showToast: { success: vi.fn(), error: vi.fn(), info: vi.fn(), warning: vi.fn(), loading: vi.fn() },
+}))
+
+vi.mock('@/stores/uiStateStore', () => ({ useUIState: vi.fn(() => false) }))
+vi.mock('@/stores/sessionStatusStore', () => ({ useSessionStatus: mocks.useSessionStatus }))
+
+vi.mock('@/contexts/EventContext', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@/contexts/EventContext')>()
+  return {
+    ...actual,
+    usePermissions: mocks.usePermissions,
+    useForms: mocks.useForms,
+  }
+})
+
+vi.mock('@/components/message/MessageThread', () => ({
+  MessageThread: vi.fn(() => <div data-testid="message-thread" />),
+}))
+vi.mock('@/components/message/PromptInput', () => ({ PromptInput: vi.fn(() => null) }))
+vi.mock('@/components/message/FloatingTTSButton', () => ({ FloatingTTSButton: vi.fn(() => null) }))
+vi.mock('@/components/message/MessageSkeleton', () => ({ MessageSkeleton: vi.fn(() => null) }))
+vi.mock('@/components/session/ContextUsageIndicator', () => ({ ContextUsageIndicator: vi.fn(() => null) }))
+vi.mock('@/components/session/SessionSendErrorBanner', () => ({ SessionSendErrorBanner: vi.fn(() => null) }))
+vi.mock('@/components/session/BackgroundWorkBar', () => ({ BackgroundWorkBar: vi.fn(() => null) }))
+vi.mock('@/components/session/SessionGoalBar', () => ({ SessionGoalBar: mocks.SessionGoalBar }))
+vi.mock('@/components/session/FormPrompt', () => ({ FormPrompt: vi.fn(() => null) }))
+vi.mock('@/components/session/MinimizedFormIndicator', () => ({ MinimizedFormIndicator: vi.fn(() => null) }))
+vi.mock('@/components/session/SessionPickerDialog', () => ({ SessionPickerDialog: mocks.SessionPickerDialog }))
+vi.mock('@/components/session/ChangesWalkthroughSheet', () => ({
+  ChangesWalkthroughSheet: mocks.ChangesWalkthroughSheet,
+}))
+vi.mock('@/components/notifications/PendingActionsGroup', () => ({
+  PendingActionsGroup: vi.fn(() => null),
+}))
+vi.mock('@/components/navigation/SessionMoreButton', () => ({ SessionMoreButton: mocks.SessionMoreButton }))
+vi.mock('@/components/navigation/ToolSidePanel', () => ({ ToolSidePanel: mocks.ToolSidePanel }))
+vi.mock('@/components/file-browser/FileBrowserSheet', () => ({ FileBrowserSheet: mocks.FileBrowserSheet }))
+vi.mock('@/components/source-control', () => ({ SourceControlPanel: mocks.SourceControlPanel }))
+vi.mock('@/components/terminal/TerminalPanel', () => ({ TerminalPanel: mocks.TerminalPanel }))
+vi.mock('@/components/preview/PreviewPanel', () => ({ PreviewPanel: mocks.PreviewPanel }))
+vi.mock('@/components/repo/ProjectActionsMenu', () => ({ ProjectActionsMenu: mocks.ProjectActionsMenu }))
+vi.mock('@/components/repo/RepoActionsDialog', () => ({ RepoActionsDialog: mocks.RepoActionsDialog }))
+vi.mock('@/components/repo/ResetPermissionsDialog', () => ({
+  ResetPermissionsDialog: mocks.ResetPermissionsDialog,
+}))
+vi.mock('@/components/repo/RepoSkillsDialog', () => ({ RepoSkillsDialog: mocks.RepoSkillsDialog }))
+vi.mock('@/components/repo/RepoMcpDialog', () => ({ RepoMcpDialog: mocks.RepoMcpDialog }))
+
+const server = {
+  id: 'srv_kitchen',
+  name: 'Kitchen',
+  baseUrl: 'https://kitchen.example.com',
+  username: 'opencode',
+  enabled: true,
+  hasPassword: true,
+  createdAt: 1,
+  updatedAt: 2,
+}
+
+const remoteSession = {
+  id: 'ses_remote',
+  projectID: 'prj_1',
+  title: 'Remote chat',
+  time: { created: 1, updated: 2 },
+  location: { directory: '/home/me/app' },
+}
+
+function createQueryClient() {
+  return new QueryClient({ defaultOptions: { queries: { retry: false } } })
+}
+
+function renderRemoteSession(sessionId = 'ses_remote') {
+  const capturedPathname = { current: '' }
+  const capturedSearch = { current: '' }
+  const rendered = render(
+    <OpenCodeServerProvider serverId="srv_kitchen">
+      <QueryClientProvider client={createQueryClient()}>
+        <MemoryRouter initialEntries={[`/servers/srv_kitchen/sessions/${sessionId}`]}>
+          <LocationCatcher capturedSearch={capturedSearch} capturedPathname={capturedPathname} />
+          <Routes>
+            <Route path="/servers/:serverId/sessions/:sessionId" element={<SessionDetail />} />
+          </Routes>
+        </MemoryRouter>
+      </QueryClientProvider>
+    </OpenCodeServerProvider>,
+  )
+
+  return { ...rendered, capturedPathname }
+}
+
+describe('SessionDetail remote server mode', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mocks.useSession.mockReturnValue({ data: remoteSession, isLoading: false, error: undefined })
+    mocks.useSessionTranscript.mockReturnValue({
+      messages: [],
+      pending: [],
+      status: 'idle',
+      isLoading: false,
+      fetchOlder: vi.fn(),
+      hasOlder: false,
+    })
+    mocks.useSSE.mockReturnValue({ isConnected: true, isReconnecting: false })
+    mocks.useRepoActivity.mockReturnValue(undefined)
+    mocks.useRepoSiblings.mockReturnValue({ data: [] })
+    mocks.usePermissions.mockReturnValue({
+      pendingCount: 0,
+      hasPermissionsForSession: vi.fn(() => false),
+      syncForSession: vi.fn(),
+    })
+    mocks.useForms.mockReturnValue({
+      current: null,
+      getForSession: vi.fn(() => null),
+      pendingCount: 0,
+      hasFormsForSession: vi.fn(() => false),
+      reply: vi.fn(),
+      cancel: vi.fn(),
+      syncForSession: vi.fn(),
+    })
+    mocks.useSettings.mockReturnValue({
+      preferences: { expandToolCalls: false },
+      updateSettings: vi.fn(),
+    })
+    mocks.useSettingsDialog.mockReturnValue({ open: vi.fn(), setActiveTab: vi.fn() })
+    mocks.useMobile.mockReturnValue(false)
+    mocks.useVisualViewport.mockReturnValue({ keyboardHeight: 0 })
+    mocks.useAutoScroll.mockReturnValue({ scrollToBottom: vi.fn(), scrollByUser: vi.fn() })
+    mocks.useDialogParam.mockReturnValue([false, vi.fn()])
+    mocks.useTerminalDialogParam.mockReturnValue([false, vi.fn()])
+    mocks.useSessionStatus.mockReturnValue({ setStatus: vi.fn() })
+    mocks.useOpenCodeServers.mockReturnValue({ servers: [server], isLoading: false })
+    mocks.useOpenCodeServerStatuses.mockReturnValue({
+      statusById: {
+        [server.id]: { serverId: server.id, connected: true, version: null, error: null },
+      },
+    })
+  })
+
+  it('does not load the Manager repo for a remote session', async () => {
+    renderRemoteSession()
+
+    await waitFor(() => {
+      expect(screen.getByTestId('message-thread')).toBeInTheDocument()
+    })
+
+    expect(mocks.getRepo).not.toHaveBeenCalled()
+    expect(mocks.useRepoActivity).toHaveBeenLastCalledWith(0, false)
+    expect(mocks.useRepoSiblings).toHaveBeenCalledWith(undefined)
+  })
+
+  it('titles the header with the server name and session directory', async () => {
+    renderRemoteSession()
+
+    await waitFor(() => {
+      expect(screen.getByText('Kitchen · app')).toBeInTheDocument()
+    })
+  })
+
+  it('uses the session directory as the only directory source', async () => {
+    renderRemoteSession()
+
+    await waitFor(() => {
+      expect(mocks.useSSE).toHaveBeenLastCalledWith('/home/me/app', 'ses_remote')
+    })
+    expect(mocks.useSessionTranscript).toHaveBeenLastCalledWith('ses_remote', '/home/me/app')
+  })
+
+  it('hides Manager-only panels and actions while keeping the remote-capable tools', async () => {
+    renderRemoteSession()
+
+    await waitFor(() => {
+      expect(screen.getByTestId('message-thread')).toBeInTheDocument()
+    })
+
+    expect(mocks.SourceControlPanel).not.toHaveBeenCalled()
+    expect(mocks.TerminalPanel).not.toHaveBeenCalled()
+    expect(mocks.PreviewPanel).not.toHaveBeenCalled()
+    expect(mocks.FileBrowserSheet).not.toHaveBeenCalled()
+    expect(mocks.ProjectActionsMenu).not.toHaveBeenCalled()
+    expect(mocks.RepoActionsDialog).not.toHaveBeenCalled()
+    expect(mocks.ResetPermissionsDialog).not.toHaveBeenCalled()
+    expect(mocks.ChangesWalkthroughSheet).not.toHaveBeenCalled()
+    expect(mocks.SessionGoalBar).not.toHaveBeenCalled()
+    expect(mocks.SessionMoreButton).not.toHaveBeenCalled()
+    expect(vi.mocked(PendingActionsGroup).mock.calls.at(-1)?.[0]).toEqual(
+      expect.objectContaining({ showScheduleReports: false }),
+    )
+  })
+
+  it('offers the MCP and skills views scoped to the remote session directory', async () => {
+    renderRemoteSession()
+
+    await waitFor(() => {
+      expect(screen.getByTestId('message-thread')).toBeInTheDocument()
+    })
+
+    expect(vi.mocked(mocks.RepoMcpDialog).mock.calls.at(-1)?.[0]).toEqual(
+      expect.objectContaining({ directory: '/home/me/app' }),
+    )
+    expect(vi.mocked(mocks.RepoSkillsDialog).mock.calls.at(-1)?.[0]).toEqual(
+      expect.objectContaining({ sessionId: 'ses_remote', directory: '/home/me/app' }),
+    )
+    expect(vi.mocked(mocks.ToolSidePanel).mock.calls.at(-1)?.[0]).toEqual(
+      expect.objectContaining({ repoDirectory: '/home/me/app', sessionId: 'ses_remote' }),
+    )
+  })
+
+  it('treats the stream as disconnected when the remote server status is disconnected', async () => {
+    mocks.useOpenCodeServerStatuses.mockReturnValue({
+      statusById: {
+        [server.id]: { serverId: server.id, connected: false, version: null, error: null },
+      },
+    })
+
+    renderRemoteSession()
+
+    await waitFor(() => {
+      expect(screen.getByTestId('message-thread')).toBeInTheDocument()
+    })
+
+    expect(vi.mocked(ContextUsageIndicator).mock.calls.at(-1)?.[0]).toEqual(
+      expect.objectContaining({ isConnected: false, isReconnecting: true }),
+    )
+    expect(vi.mocked(SessionSendErrorBanner).mock.calls.at(-1)?.[0]).toEqual(
+      expect.objectContaining({ isConnected: false, isReconnecting: true }),
+    )
+  })
+
+  it('treats the stream as connected when both the Manager stream and remote server are connected', async () => {
+    renderRemoteSession()
+
+    await waitFor(() => {
+      expect(screen.getByTestId('message-thread')).toBeInTheDocument()
+    })
+
+    expect(vi.mocked(ContextUsageIndicator).mock.calls.at(-1)?.[0]).toEqual(
+      expect.objectContaining({ isConnected: true, isReconnecting: false }),
+    )
+    expect(vi.mocked(SessionSendErrorBanner).mock.calls.at(-1)?.[0]).toEqual(
+      expect.objectContaining({ isConnected: true, isReconnecting: false }),
+    )
+  })
+
+  it('treats the stream as disconnected when the Manager stream drops even if the remote server is connected', async () => {
+    mocks.useSSE.mockReturnValue({ isConnected: false, isReconnecting: true })
+
+    renderRemoteSession()
+
+    await waitFor(() => {
+      expect(screen.getByTestId('message-thread')).toBeInTheDocument()
+    })
+
+    expect(vi.mocked(ContextUsageIndicator).mock.calls.at(-1)?.[0]).toEqual(
+      expect.objectContaining({ isConnected: false, isReconnecting: true }),
+    )
+  })
+
+  it('navigates child sessions within the linked server route', async () => {
+    const { capturedPathname } = renderRemoteSession()
+
+    await waitFor(() => {
+      expect(screen.getByTestId('message-thread')).toBeInTheDocument()
+    })
+
+    const threadProps = vi.mocked(MessageThread).mock.calls.at(-1)?.[0]
+    expect(threadProps?.onFileClick).toBeUndefined()
+    expect(threadProps?.onOpenWalkthrough).toBeUndefined()
+
+    act(() => {
+      threadProps?.onChildSessionClick?.('ses_child')
+    })
+
+    expect(capturedPathname.current).toBe('/servers/srv_kitchen/sessions/ses_child')
+  })
+
+  it('renders the session picker scoped to the linked server', async () => {
+    renderRemoteSession()
+
+    await waitFor(() => {
+      expect(screen.getByTestId('message-thread')).toBeInTheDocument()
+    })
+
+    const pickerProps = mocks.SessionPickerDialog.mock.calls.at(-1)?.[0]
+    expect(pickerProps).toEqual(
+      expect.objectContaining({
+        open: false,
+        currentRepo: undefined,
+        activeSessionID: 'ses_remote',
+        remote: {
+          serverId: 'srv_kitchen',
+          serverName: 'Kitchen',
+          projectDirectory: '/home/me/app',
+        },
+      }),
+    )
+  })
+
+  it('opens the session picker from the sessions shortcut on a remote route', async () => {
+    renderRemoteSession()
+
+    await waitFor(() => {
+      expect(screen.getByTestId('message-thread')).toBeInTheDocument()
+    })
+
+    const actions = mocks.useShortcutActions.mock.calls.at(-1)?.[0]
+    act(() => {
+      actions?.sessions?.()
+    })
+
+    await waitFor(() => {
+      expect(mocks.SessionPickerDialog.mock.calls.at(-1)?.[0]).toEqual(
+        expect.objectContaining({ open: true, remote: expect.objectContaining({ serverId: 'srv_kitchen' }) }),
+      )
+    })
+  })
+
+  it('navigates to a session chosen from the remote picker', async () => {
+    const { capturedPathname } = renderRemoteSession()
+
+    await waitFor(() => {
+      expect(screen.getByTestId('message-thread')).toBeInTheDocument()
+    })
+
+    const pickerProps = mocks.SessionPickerDialog.mock.calls.at(-1)?.[0]
+    act(() => {
+      pickerProps?.onSelectRemoteSession?.({ ...remoteSession, id: 'ses_other' }, 'srv_kitchen')
+    })
+
+    expect(capturedPathname.current).toBe('/servers/srv_kitchen/sessions/ses_other')
+  })
+
+  it('shows a loader until the session directory is available', async () => {
+    mocks.useSession.mockReturnValue({ data: undefined, isLoading: true, error: undefined })
+
+    renderRemoteSession()
+
+    expect(screen.getByText('Loading session...')).toBeInTheDocument()
+    expect(mocks.getRepo).not.toHaveBeenCalled()
+  })
+})
diff --git a/frontend/src/stores/sessionStatusStore.test.ts b/frontend/src/stores/sessionStatusStore.test.ts
index ccc1be3b1..59a8ef032 100644
--- a/frontend/src/stores/sessionStatusStore.test.ts
+++ b/frontend/src/stores/sessionStatusStore.test.ts
@@ -10,6 +10,7 @@ const resetStore = () => {
     outcomes: new Map(),
     parents: new Map(),
     directories: new Map(),
+    sessionServers: new Map(),
     runningShells: new Map(),
     shellRevisions: new Map(),
     shellRevision: 0,
@@ -45,6 +46,98 @@ describe('sessionStatusStore', () => {
     useSessionStatus.getState().clearStatus('session-a')
   })
 
+  it('keeps a remote server session status across a local snapshot', () => {
+    const store = useSessionStatus.getState()
+    store.setSessionServer('session-remote', 'srv_remote')
+    store.setStatus('session-remote', { type: 'busy' })
+
+    const token = store.beginStatusSnapshot()
+    useSessionStatus.getState().replaceStatuses({}, token)
+
+    expect(useSessionStatus.getState().getStatus('session-remote')).toEqual({ type: 'busy' })
+    expect(useSessionStatus.getState().knownSessions.has('session-remote')).toBe(true)
+  })
+
+  it('does not record ownership for a local session server', () => {
+    const store = useSessionStatus.getState()
+    store.setSessionServer('session-local', 'local')
+
+    expect(useSessionStatus.getState().sessionServers.has('session-local')).toBe(false)
+  })
+
+  it('removes a stale busy status owned by the reconciled server', () => {
+    const store = useSessionStatus.getState()
+    store.setSessionServer('session-remote', 'srv_remote')
+    store.setStatus('session-remote', { type: 'busy' })
+
+    const token = store.beginStatusSnapshot()
+    useSessionStatus.getState().replaceServerStatuses('srv_remote', {}, token)
+
+    expect(useSessionStatus.getState().getStatus('session-remote')).toEqual({ type: 'idle' })
+    expect(useSessionStatus.getState().knownSessions.has('session-remote')).toBe(false)
+  })
+
+  it('keeps statuses owned by another server or by the local server during a server snapshot', () => {
+    const store = useSessionStatus.getState()
+    store.setSessionServer('session-remote-a', 'srv_remote_a')
+    store.setStatus('session-remote-a', { type: 'busy' })
+    store.setSessionServer('session-remote-b', 'srv_remote_b')
+    store.setStatus('session-remote-b', { type: 'busy' })
+    store.setStatus('session-local', { type: 'busy' })
+
+    const token = store.beginStatusSnapshot()
+    useSessionStatus.getState().replaceServerStatuses('srv_remote_a', {}, token)
+
+    expect(useSessionStatus.getState().getStatus('session-remote-a')).toEqual({ type: 'idle' })
+    expect(useSessionStatus.getState().getStatus('session-remote-b')).toEqual({ type: 'busy' })
+    expect(useSessionStatus.getState().getStatus('session-local')).toEqual({ type: 'busy' })
+    expect(useSessionStatus.getState().knownSessions.has('session-remote-b')).toBe(true)
+    expect(useSessionStatus.getState().knownSessions.has('session-local')).toBe(true)
+  })
+
+  it('does not let a server snapshot clobber a live status update made after it began', () => {
+    const store = useSessionStatus.getState()
+    store.setSessionServer('session-remote', 'srv_remote')
+    store.setStatus('session-remote', { type: 'busy' })
+
+    const token = store.beginStatusSnapshot()
+    store.setStatus('session-remote', { type: 'idle' })
+
+    useSessionStatus.getState().replaceServerStatuses(
+      'srv_remote',
+      { 'session-remote': { type: 'busy' } },
+      token,
+    )
+
+    expect(useSessionStatus.getState().getStatus('session-remote')).toEqual({ type: 'idle' })
+    expect(useSessionStatus.getState().knownSessions.has('session-remote')).toBe(true)
+  })
+
+  it('records snapshot sessions as owned by the reconciled server', () => {
+    const token = useSessionStatus.getState().beginStatusSnapshot()
+
+    useSessionStatus.getState().replaceServerStatuses(
+      'srv_remote',
+      { 'session-remote': { type: 'busy' } },
+      token,
+    )
+
+    expect(useSessionStatus.getState().getStatus('session-remote')).toEqual({ type: 'busy' })
+    expect(useSessionStatus.getState().sessionServers.get('session-remote')).toBe('srv_remote')
+    expect(useSessionStatus.getState().knownSessions.has('session-remote')).toBe(true)
+  })
+
+  it('forgets the recorded server of a deleted session', () => {
+    const store = useSessionStatus.getState()
+    store.setSessionServer('session-remote', 'srv_remote')
+    store.setStatus('session-remote', { type: 'busy' })
+
+    store.forgetSession('session-remote')
+
+    expect(useSessionStatus.getState().sessionServers.has('session-remote')).toBe(false)
+    expect(useSessionStatus.getState().getStatus('session-remote')).toEqual({ type: 'idle' })
+  })
+
   it('keeps a more specific live status when a snapshot reports the session as busy', () => {
     const store = useSessionStatus.getState()
     const retry = { type: 'retry' as const, attempt: 2, message: 'rate limited', next: 1234 }
diff --git a/frontend/src/stores/sessionStatusStore.ts b/frontend/src/stores/sessionStatusStore.ts
index 649abfb61..fd221e080 100644
--- a/frontend/src/stores/sessionStatusStore.ts
+++ b/frontend/src/stores/sessionStatusStore.ts
@@ -1,4 +1,5 @@
 import { create } from 'zustand'
+import { LOCAL_OPENCODE_SERVER_ID } from '@opencode-manager/shared/schemas'
 import type { SessionInfo } from '@opencode-manager/shared/opencode'
 import { childLifecycle, type BackgroundTaskLifecycle, type ChildOutcome } from '@/lib/backgroundWork'
 
@@ -31,6 +32,7 @@ interface SessionStatusStore {
   outcomes: Map<string, ChildOutcome>
   parents: Map<string, string | null>
   directories: Map<string, string>
+  sessionServers: Map<string, string>
   runningShells: Map<string, RunningShell>
   shellRevisions: Map<string, number>
   shellRevision: number
@@ -40,6 +42,7 @@ interface SessionStatusStore {
   clearOutcome: (sessionID: string) => void
   setOptimisticActive: (sessionID: string, timeoutMs?: number) => void
   replaceStatuses: (statuses: Record<string, SessionStatusType>, token: StatusSnapshotToken) => void
+  replaceServerStatuses: (serverId: string, statuses: Record<string, SessionStatusType>, token: StatusSnapshotToken) => void
   applySessionSnapshot: (sessionID: string, session: SessionInfo, token: StatusSnapshotToken) => void
   beginStatusSnapshot: () => StatusSnapshotToken
   endStatusSnapshot: (token: StatusSnapshotToken) => void
@@ -47,6 +50,7 @@ interface SessionStatusStore {
   clearStatus: (sessionID: string) => void
   setSessionParent: (sessionID: string, parentID: string | null) => void
   setSessionDirectory: (sessionID: string, directory: string) => void
+  setSessionServer: (sessionID: string, serverId: string) => void
   setShellRunning: (shellID: string, sessionID: string, directory: string) => void
   clearShell: (shellID: string) => void
   replaceRunningShells: (directory: string, shells: Array<{ id: string; sessionID: string }>, token: ShellSnapshotToken) => void
@@ -61,6 +65,7 @@ const optimisticActiveTimers = new Map<string, ReturnType<typeof setTimeout>>()
 const inFlightSnapshots = new Map<number, number>()
 let snapshotOrderCounter = 0
 let lastAppliedSnapshotOrder = 0
+const lastAppliedServerSnapshotOrders = new Map<string, number>()
 const inFlightShellSnapshots = new Map<number, number>()
 let shellSnapshotOrderCounter = 0
 
@@ -150,6 +155,21 @@ const markSessionKnown = (knownSessions: Set<string>, sessionID: string): Set<st
   return next
 }
 
+const withServerOwnership = (
+  sessionServers: Map<string, string>,
+  sessionIDs: string[],
+  serverId: string,
+): Map<string, string> | null => {
+  if (serverId === LOCAL_OPENCODE_SERVER_ID) return null
+  let next: Map<string, string> | null = null
+  for (const sessionID of sessionIDs) {
+    if (sessionServers.get(sessionID) === serverId) continue
+    next ??= new Map(sessionServers)
+    next.set(sessionID, serverId)
+  }
+  return next
+}
+
 const registerSnapshot = (token: StatusSnapshotToken): void => {
   inFlightSnapshots.set(token.order, token.revision)
 }
@@ -240,6 +260,82 @@ export const useSessionStatus = create<SessionStatusStore>((set, get) => {
     return touched !== undefined && touched > captureRevision
   }
 
+  const isRemoteOwned = (sessionID: string): boolean => get().sessionServers.has(sessionID)
+
+  const buildStatusSnapshotPatch = (
+    state: SessionStatusStore,
+    statuses: Record<string, SessionStatusType>,
+    captureRevision: number,
+    keepsCurrentStatus: (sessionID: string) => boolean,
+    snapshotServerId: string | null,
+  ): Partial<SessionStatusStore> | null => {
+    const currentStatuses = state.statuses
+    const currentRevisions = state.statusRevisions
+    const currentKnownSessions = state.knownSessions
+
+    const newMap = new Map<string, SessionStatusType>()
+    const newCache = new Map<string, string>()
+
+    for (const [sessionID, status] of currentStatuses.entries()) {
+      if (!keepsCurrentStatus(sessionID)) continue
+      newMap.set(sessionID, status)
+      newCache.set(sessionID, getStatusHash(status))
+    }
+
+    const snapshotSessionIDs: string[] = []
+    for (const [sessionID, status] of Object.entries(statuses)) {
+      if (isLiveAfterCapture(sessionID, captureRevision)) continue
+      if (status.type === 'idle') continue
+      const current = currentStatuses.get(sessionID)
+      const effective = status.type === 'busy' && current !== undefined && current.type !== 'idle' ? current : status
+      newMap.set(sessionID, effective)
+      newCache.set(sessionID, getStatusHash(effective))
+      snapshotSessionIDs.push(sessionID)
+    }
+
+    const nextRevisions = prunedRevisions(currentRevisions)
+    const nextKnownSessions = new Set<string>(Object.keys(statuses))
+    for (const [sessionID, revision] of currentRevisions.entries()) {
+      if (revision > captureRevision) nextKnownSessions.add(sessionID)
+    }
+    for (const sessionID of optimisticActiveTimers.keys()) {
+      nextKnownSessions.add(sessionID)
+    }
+    for (const sessionID of newMap.keys()) {
+      nextKnownSessions.add(sessionID)
+    }
+    for (const sessionID of currentKnownSessions) {
+      if (!currentStatuses.has(sessionID)) nextKnownSessions.add(sessionID)
+    }
+
+    const sessionServers = snapshotServerId === null
+      ? null
+      : withServerOwnership(state.sessionServers, snapshotSessionIDs, snapshotServerId)
+
+    if (
+      sessionServers === null &&
+      sameEntries(state.statusCache, newCache) &&
+      sameEntries(currentRevisions, nextRevisions) &&
+      sameSets(currentKnownSessions, nextKnownSessions)
+    ) return null
+
+    return {
+      statuses: newMap,
+      statusCache: newCache,
+      statusRevisions: nextRevisions,
+      knownSessions: nextKnownSessions,
+      ...(sessionServers === null ? {} : { sessionServers }),
+    }
+  }
+
+  const pruneRevisionsForRejectedSnapshot = (): void => {
+    const currentRevisions = get().statusRevisions
+    const nextRevisions = prunedRevisions(currentRevisions)
+    if (!sameEntries(currentRevisions, nextRevisions)) {
+      set({ statusRevisions: nextRevisions })
+    }
+  }
+
   return {
     statuses: new Map(),
     statusCache: new Map(),
@@ -248,6 +344,7 @@ export const useSessionStatus = create<SessionStatusStore>((set, get) => {
     outcomes: new Map(),
     parents: new Map(),
     directories: new Map(),
+    sessionServers: new Map(),
     runningShells: new Map(),
     shellRevisions: new Map(),
     shellRevision: 0,
@@ -336,11 +433,7 @@ export const useSessionStatus = create<SessionStatusStore>((set, get) => {
       releaseSnapshot(token)
 
       if (token.order < lastAppliedSnapshotOrder) {
-        const currentRevisions = get().statusRevisions
-        const nextRevisions = prunedRevisions(currentRevisions)
-        if (!sameEntries(currentRevisions, nextRevisions)) {
-          set({ statusRevisions: nextRevisions })
-        }
+        pruneRevisionsForRejectedSnapshot()
         return
       }
       lastAppliedSnapshotOrder = token.order
@@ -349,53 +442,37 @@ export const useSessionStatus = create<SessionStatusStore>((set, get) => {
         clearOptimisticActiveTimer(sessionID)
       }
 
-      const currentStatuses = get().statuses
-      const currentRevisions = get().statusRevisions
-      const currentKnownSessions = get().knownSessions
-      const captureRevision = token.revision
-
-      const newMap = new Map<string, SessionStatusType>()
-      const newCache = new Map<string, string>()
+      const patch = buildStatusSnapshotPatch(
+        get(),
+        statuses,
+        token.revision,
+        (sessionID) => isLiveAfterCapture(sessionID, token.revision) || isRemoteOwned(sessionID),
+        null,
+      )
+      if (patch) set(patch)
+    },
 
-      for (const [sessionID, status] of currentStatuses.entries()) {
-        if (!isLiveAfterCapture(sessionID, captureRevision)) continue
-        newMap.set(sessionID, status)
-        newCache.set(sessionID, getStatusHash(status))
-      }
+    replaceServerStatuses: (serverId: string, statuses: Record<string, SessionStatusType>, token: StatusSnapshotToken) => {
+      releaseSnapshot(token)
 
-      for (const [sessionID, status] of Object.entries(statuses)) {
-        if (isLiveAfterCapture(sessionID, captureRevision)) continue
-        if (status.type === 'idle') continue
-        const current = currentStatuses.get(sessionID)
-        const effective = status.type === 'busy' && current !== undefined && current.type !== 'idle' ? current : status
-        newMap.set(sessionID, effective)
-        newCache.set(sessionID, getStatusHash(effective))
+      if (token.order < (lastAppliedServerSnapshotOrders.get(serverId) ?? 0)) {
+        pruneRevisionsForRejectedSnapshot()
+        return
       }
+      lastAppliedServerSnapshotOrders.set(serverId, token.order)
 
-      const nextRevisions = prunedRevisions(currentRevisions)
-      const nextKnownSessions = new Set<string>(Object.keys(statuses))
-      for (const [sessionID, revision] of currentRevisions.entries()) {
-        if (revision > captureRevision) nextKnownSessions.add(sessionID)
-      }
-      for (const sessionID of optimisticActiveTimers.keys()) {
-        nextKnownSessions.add(sessionID)
-      }
-      for (const sessionID of currentKnownSessions) {
-        if (!currentStatuses.has(sessionID)) nextKnownSessions.add(sessionID)
+      for (const sessionID of Object.keys(statuses)) {
+        clearOptimisticActiveTimer(sessionID)
       }
 
-      if (
-        sameEntries(get().statusCache, newCache) &&
-        sameEntries(currentRevisions, nextRevisions) &&
-        sameSets(currentKnownSessions, nextKnownSessions)
-      ) return
-
-      set({
-        statuses: newMap,
-        statusCache: newCache,
-        statusRevisions: nextRevisions,
-        knownSessions: nextKnownSessions,
-      })
+      const patch = buildStatusSnapshotPatch(
+        get(),
+        statuses,
+        token.revision,
+        (sessionID) => isLiveAfterCapture(sessionID, token.revision) || get().sessionServers.get(sessionID) !== serverId,
+        serverId,
+      )
+      if (patch) set(patch)
     },
 
     beginStatusSnapshot: () => {
@@ -460,6 +537,16 @@ export const useSessionStatus = create<SessionStatusStore>((set, get) => {
       })
     },
 
+    setSessionServer: (sessionID: string, serverId: string) => {
+      if (serverId === LOCAL_OPENCODE_SERVER_ID) return
+      if (get().sessionServers.get(sessionID) === serverId) return
+      set((state) => {
+        const sessionServers = new Map(state.sessionServers)
+        sessionServers.set(sessionID, serverId)
+        return { sessionServers }
+      })
+    },
+
     setShellRunning: (shellID: string, sessionID: string, directory: string) => {
       const current = get().runningShells.get(shellID)
       if (current && current.sessionID === sessionID && current.directory === directory) {
@@ -546,6 +633,7 @@ export const useSessionStatus = create<SessionStatusStore>((set, get) => {
         current.outcomes.has(sessionID) ||
         current.parents.has(sessionID) ||
         current.directories.has(sessionID) ||
+        current.sessionServers.has(sessionID) ||
         ownsShell
       if (!hasSession && inFlightSnapshots.size === 0) return
 
@@ -556,6 +644,7 @@ export const useSessionStatus = create<SessionStatusStore>((set, get) => {
         const outcomes = new Map(state.outcomes)
         const parents = new Map(state.parents)
         const directories = new Map(state.directories)
+        const sessionServers = new Map(state.sessionServers)
         const runningShells = new Map(state.runningShells)
         statuses.delete(sessionID)
         statusCache.delete(sessionID)
@@ -563,6 +652,7 @@ export const useSessionStatus = create<SessionStatusStore>((set, get) => {
         outcomes.delete(sessionID)
         parents.delete(sessionID)
         directories.delete(sessionID)
+        sessionServers.delete(sessionID)
         const removedShellIDs: string[] = []
         for (const [shellID, shell] of runningShells.entries()) {
           if (shell.sessionID !== sessionID) continue
@@ -576,6 +666,7 @@ export const useSessionStatus = create<SessionStatusStore>((set, get) => {
           outcomes,
           parents,
           directories,
+          sessionServers,
           runningShells,
           ...(shellTouchPatch(state, removedShellIDs) ?? {}),
           ...(recordRevisionPatch(state, sessionID) ?? {}),
diff --git a/ocm-cli/README.md b/ocm-cli/README.md
index 748af819e..76929d0f1 100644
--- a/ocm-cli/README.md
+++ b/ocm-cli/README.md
@@ -97,6 +97,8 @@ ocm use <repoId|name>
 ocm push [repoId] [--force] [--create] [--yes] [--full]
 ocm pull [repoId] [--force] [--full]
 ocm install [--dir <path>] [--force] [--no-link]
+ocm link [--url <url>] [--password <pw>] [--username <name>] [--name <name>]
+         [--pair-host <host>] [--pair-port <port>] [--ttl <seconds>] [--no-qr]
 ocm logout
 ocm --version
 ocm --help
@@ -155,6 +157,43 @@ repos matching the current project (the command fails clearly otherwise), and
 any ambiguity message lists each match with its id, kind (repo or worktree),
 branch, and path. The default attach reports the same details.
 
+## Link a raw OpenCode server
+
+Run `ocm link` on a machine that hosts a bare `opencode serve` to pair it with
+OpenCode Manager without copying the password by hand:
+
+```bash
+OPENCODE_SERVER_PASSWORD=... ocm link
+```
+
+It prints a terminal QR code and an `ocm://link` URL. Scanning or pasting that
+into the Manager adds the server with its name, base URL, username, and
+password.
+
+| Flag | Default |
+|---|---|
+| `--url <url>` | `$OPENCODE_SERVER_URL`, else `http://<first non-internal IPv4>:4096` |
+| `--password <pw>` | `$OPENCODE_SERVER_PASSWORD` (required) |
+| `--username <name>` | `$OPENCODE_SERVER_USERNAME`, else `opencode` |
+| `--name <name>` | the machine hostname |
+| `--pair-host <host>` | the host of `--url` |
+| `--pair-port <port>` | `0` (ephemeral) |
+| `--ttl <seconds>` | `300` |
+| `--no-qr` | off; print only the link |
+
+Before showing the code it calls `GET <url>/api/info` with Basic auth and warns
+when the server is unreachable; a `401` stops the command. The command then
+listens on `0.0.0.0` for one `POST /redeem`. The pairing code never crosses the
+network: the Manager sends a random nonce and an HMAC-SHA256 proof of the code,
+and the listener answers with the credentials encrypted with AES-256-GCM under a
+key derived from the code and the nonce (HKDF-SHA256). It then prints `Linked`
+and exits. A malformed request returns `400`, a wrong proof returns `401`, and
+the third failure ends the command; the TTL ends it with `Pairing code expired`.
+Links use version `v=2`; the Manager rejects older links with a message to
+update. The pairing listener and the OpenCode server itself still use plain HTTP
+unless you put them behind TLS, so use HTTPS or a private network for the
+server traffic.
+
 ## OpenCode TUI plugin
 
 The package exposes an OpenCode 2 TUI plugin (`{ id, setup }`) through its `./tui`
diff --git a/ocm-cli/bin/ocm.ts b/ocm-cli/bin/ocm.ts
index 9f8cbfb66..9f469be2e 100644
--- a/ocm-cli/bin/ocm.ts
+++ b/ocm-cli/bin/ocm.ts
@@ -1,6 +1,9 @@
 import { spawn, spawnSync } from 'child_process'
+import { hostname } from 'os'
 import { basename, dirname, resolve } from 'path'
 import { fileURLToPath } from 'url'
+import { buildOpenCodeServerLink, OPENCODE_SERVER_USERNAME } from '@opencode-manager/shared/schemas'
+import { trimUrlTrailingSlashes } from '@opencode-manager/shared/utils'
 import { readState, writeState, clearState, getStatePath, writeInstallNotice, type OcmState } from '../src/state.js'
 import { installVendoredOcm, resolveOpenCodeConfigDir, InstallError, OCM_PLUGIN_SPEC } from '../src/vendor-install.js'
 import { setToken, deleteToken, hasStoredToken, describeTokenStore, describeTokenWriteTarget, envToken, TOKEN_ENV, TokenStoreError } from '../src/internal-token-store.js'
@@ -14,8 +17,9 @@ import { resolveTarget, formatRepoIdentities, parseRepoIdPositional, restrictMat
 import { buildAttachInvocation } from '../src/warp.js'
 import { type ManagerRepo, fetchRepos, toRemoteRepoSummaries } from '../src/manager-repos.js'
 import { OCM_VERSION as VERSION, warmRepoProxy } from '../src/repo-proxy.js'
-import { normalizeManagerUrl, resolveManagerAuth } from '../src/manager-auth.js'
+import { resolveManagerAuth } from '../src/manager-auth.js'
 import type { ManagerAuthOk } from '../src/manager-auth.js'
+import { generatePairingCode, probeOpenCodeServer, renderPairingQr, resolveDefaultBaseUrl, startPairingServer } from '../src/link.js'
 
 const USAGE = `ocm v${VERSION} - OpenCode Manager workspace launcher
 
@@ -36,6 +40,10 @@ Usage:
                                                   Mirror the matching Manager repo over $PWD (fast patch sync by default)
   ocm install [--dir <path>] [--force] [--no-link]
                                                   Vendor the CLI + TUI plugin into the OpenCode config dir
+  ocm link [--url <url>] [--password <pw>] [--username <name>] [--name <name>]
+           [--pair-host <host>] [--pair-port <port>] [--ttl <seconds>] [--no-qr]
+                                                  Pair a Manager with this machine's opencode serve
+                                                  by scanning a QR code
   ocm --version             Show the installed ocm version
   ocm --help                Show this help
 `
@@ -49,6 +57,10 @@ function info(msg: string): void {
   process.stdout.write(`${msg}\n`)
 }
 
+function warn(msg: string): void {
+  process.stderr.write(`ocm: warning: ${msg}\n`)
+}
+
 function promptYesNo(question: string): boolean {
   process.stderr.write(`${question} [y/N] `)
   const res = spawnSync('bash', ['-c', 'read LINE && printf "%s" "$LINE"'], {
@@ -160,7 +172,7 @@ function parseLoginArgs(args: string[]): { url: string; token?: string; managerN
 
 export async function cmdLogin(args: string[]): Promise<void> {
   const { url, token: providedToken, managerName } = parseLoginArgs(args)
-  const normalisedUrl = normalizeManagerUrl(url)
+  const normalisedUrl = trimUrlTrailingSlashes(url)
 
   let token = providedToken
   if (!token) {
@@ -190,7 +202,7 @@ export async function cmdLogin(args: string[]): Promise<void> {
   }
 
   const existing = readState()
-  const sameManager = existing ? normalizeManagerUrl(existing.managerUrl) === normalisedUrl : false
+  const sameManager = existing ? trimUrlTrailingSlashes(existing.managerUrl) === normalisedUrl : false
   writeState({
     ...existing,
     managerUrl: normalisedUrl,
@@ -601,6 +613,146 @@ export async function cmdInstall(args: string[]): Promise<void> {
   }
 }
 
+const LINK_USAGE = `usage: ocm link [--url <url>] [--password <pw>] [--username <name>] [--name <name>]
+                 [--pair-host <host>] [--pair-port <port>] [--ttl <seconds>] [--no-qr]`
+
+const LINK_FLAGS: Record<string, 'url' | 'password' | 'username' | 'name' | 'pairHost' | 'pairPort' | 'ttl'> = {
+  '--url': 'url',
+  '--password': 'password',
+  '--username': 'username',
+  '--name': 'name',
+  '--pair-host': 'pairHost',
+  '--pair-port': 'pairPort',
+  '--ttl': 'ttl',
+}
+
+const PAIRING_MAX_ATTEMPTS = 3
+
+interface LinkCommandOptions {
+  baseUrl: string
+  username: string
+  password: string
+  name: string
+  pairHost: string
+  pairPort: number
+  ttlMs: number
+  showQr: boolean
+}
+
+function parseLinkInteger(value: string, flag: string, min: number, max: number): number {
+  const parsed = Number(value)
+  if (!Number.isInteger(parsed) || parsed < min || parsed > max) {
+    die(`${flag} must be an integer between ${min} and ${max}`)
+  }
+  return parsed
+}
+
+function normalizeLinkBaseUrl(value: string): string {
+  let parsed: URL
+  try {
+    parsed = new URL(value)
+  } catch {
+    die(`invalid --url: ${value}`)
+  }
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+    die(`invalid --url: ${value} (expected http:// or https://)`)
+  }
+  return parsed.href.replace(/\/+$/, '')
+}
+
+function parseLinkArgs(args: string[]): LinkCommandOptions {
+  const values: Partial<Record<'url' | 'password' | 'username' | 'name' | 'pairHost' | 'pairPort' | 'ttl', string>> = {}
+  let showQr = true
+
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index]!
+    if (arg === '--no-qr') {
+      showQr = false
+      continue
+    }
+    const key = LINK_FLAGS[arg]
+    if (!key) die(`unknown option: ${arg}. run \`ocm --help\``)
+    const value = args[index + 1]
+    if (!value || value.startsWith('--')) die(LINK_USAGE)
+    values[key] = value
+    index++
+  }
+
+  const baseUrl = normalizeLinkBaseUrl(values.url ?? process.env.OPENCODE_SERVER_URL ?? resolveDefaultBaseUrl())
+  const password = values.password ?? process.env.OPENCODE_SERVER_PASSWORD
+  if (!password) die('no OpenCode password: pass --password or set OPENCODE_SERVER_PASSWORD')
+
+  return {
+    baseUrl,
+    username: values.username ?? process.env.OPENCODE_SERVER_USERNAME ?? OPENCODE_SERVER_USERNAME,
+    password,
+    name: values.name ?? hostname(),
+    pairHost: values.pairHost ?? new URL(baseUrl).hostname,
+    pairPort: parseLinkInteger(values.pairPort ?? '0', '--pair-port', 0, 65535),
+    ttlMs: parseLinkInteger(values.ttl ?? '300', '--ttl', 1, 86400) * 1000,
+    showQr,
+  }
+}
+
+export async function cmdLink(args: string[]): Promise<void> {
+  if (args.includes('--help') || args.includes('-h')) {
+    info(LINK_USAGE)
+    return
+  }
+
+  const options = parseLinkArgs(args)
+  const credentials = { username: options.username, password: options.password }
+
+  const probe = await probeOpenCodeServer(options.baseUrl, credentials)
+  if (probe.status === 'unauthorized') {
+    die(`OpenCode at ${options.baseUrl} rejected the credentials (401); check --username and --password`)
+  }
+  if (probe.status === 'unreachable') {
+    warn(`could not reach ${options.baseUrl} (${probe.message}); pairing anyway`)
+  } else {
+    info(`OpenCode${probe.version ? ` ${probe.version}` : ''} at ${options.baseUrl}`)
+  }
+
+  const code = generatePairingCode()
+  const pairing = await startPairingServer({
+    code,
+    credentials,
+    ttlMs: options.ttlMs,
+    maxAttempts: PAIRING_MAX_ATTEMPTS,
+    port: options.pairPort,
+    hostname: options.pairHost,
+  })
+
+  const link = buildOpenCodeServerLink({
+    kind: 'opencode',
+    name: options.name,
+    baseUrl: options.baseUrl,
+    pairing: { pairUrl: pairing.url, code },
+  })
+
+  const expiresAt = new Date(Date.now() + options.ttlMs)
+  if (options.showQr) {
+    info('')
+    info(renderPairingQr(link))
+  }
+  info('')
+  info(`Link: ${link}`)
+  info(`Pairing URL: ${pairing.url}`)
+  info(`Expires: ${expiresAt.toISOString()} (in ${Math.round(options.ttlMs / 1000)}s)`)
+  warn('the pairing listener uses plain HTTP; use it only on a private network.')
+  info('Waiting for OpenCode Manager to scan the code...')
+
+  const outcome = await pairing.done
+  await pairing.close()
+
+  if (outcome === 'linked') {
+    info('Linked')
+    return
+  }
+  if (outcome === 'expired') die('Pairing code expired')
+  die('too many invalid pairing attempts; no Manager was linked')
+}
+
 async function main(): Promise<void> {
   const [, , cmd, ...rest] = process.argv
 
@@ -645,6 +797,9 @@ async function main(): Promise<void> {
       case 'install':
         await cmdInstall(rest)
         break
+      case 'link':
+        await cmdLink(rest)
+        break
       default:
         die(`unknown command: ${cmd}. run \`ocm --help\``)
     }
diff --git a/ocm-cli/package.json b/ocm-cli/package.json
index d90c156d2..249ff9261 100644
--- a/ocm-cli/package.json
+++ b/ocm-cli/package.json
@@ -65,6 +65,7 @@
     "solid-js": "1.9.12",
     "typescript": "^5.5.0",
     "typescript-eslint": "^8.45.0",
+    "uqr": "^0.1.3",
     "vitest": "^3.1.0"
   }
 }
diff --git a/ocm-cli/src/link.ts b/ocm-cli/src/link.ts
new file mode 100644
index 000000000..887f168c5
--- /dev/null
+++ b/ocm-cli/src/link.ts
@@ -0,0 +1,261 @@
+import { randomBytes } from 'node:crypto'
+import { createServer, type IncomingMessage, type ServerResponse } from 'node:http'
+import { networkInterfaces, type NetworkInterfaceInfo } from 'node:os'
+import { renderUnicodeCompact } from 'uqr'
+import {
+  buildOpenCodeBasicAuth,
+  encryptOpenCodePairingCredentials,
+  isOpenCodePairingNonce,
+  verifyOpenCodePairingProof,
+  type OpenCodePairingCredentials,
+  type OpenCodePairingEncryptedCredentials,
+} from '@opencode-manager/shared/opencode'
+import { trimUrlTrailingSlashes } from '@opencode-manager/shared/utils'
+
+const DEFAULT_OPENCODE_PORT = 4096
+const REDEEM_PATH = '/redeem'
+const MAX_BODY_BYTES = 4096
+
+export type PairingCredentials = OpenCodePairingCredentials
+
+export type PairingOutcome = 'linked' | 'expired' | 'rejected'
+
+export interface PairingServerOptions {
+  code: string
+  credentials: PairingCredentials
+  ttlMs: number
+  maxAttempts: number
+  port?: number
+  hostname?: string
+}
+
+export interface PairingServerHandle {
+  url: string
+  port: number
+  done: Promise<PairingOutcome>
+  close: () => Promise<void>
+}
+
+export type OpenCodeServerProbe =
+  | { status: 'ok'; version: string | null }
+  | { status: 'unauthorized' }
+  | { status: 'unreachable'; message: string }
+
+/** Generates a 32-byte random pairing code encoded as base64url. */
+export function generatePairingCode(): string {
+  return randomBytes(32).toString('base64url')
+}
+
+/** Picks the OpenCode base URL from the first non-internal IPv4 interface, else loopback. */
+export function resolveDefaultBaseUrl(
+  interfaces: NodeJS.Dict<NetworkInterfaceInfo[]> = networkInterfaces(),
+): string {
+  for (const entries of Object.values(interfaces)) {
+    for (const entry of entries ?? []) {
+      if (entry.family === 'IPv4' && !entry.internal) {
+        return `http://${entry.address}:${DEFAULT_OPENCODE_PORT}`
+      }
+    }
+  }
+  return `http://127.0.0.1:${DEFAULT_OPENCODE_PORT}`
+}
+
+/** Renders the pairing link as a half-block QR code for terminals. */
+export function renderPairingQr(link: string): string {
+  return renderUnicodeCompact(link, { ecc: 'M', border: 2 })
+}
+
+/** Probes `<baseUrl>/api/info` with Basic auth to report reachability and credentials validity. */
+export async function probeOpenCodeServer(
+  baseUrl: string,
+  credentials: PairingCredentials,
+  timeoutMs = 3000,
+): Promise<OpenCodeServerProbe> {
+  const authorization = buildOpenCodeBasicAuth(credentials.password, credentials.username)
+  try {
+    const response = await fetch(`${trimUrlTrailingSlashes(baseUrl)}/api/info`, {
+      headers: { authorization },
+      signal: AbortSignal.timeout(timeoutMs),
+    })
+    if (response.status === 401) return { status: 'unauthorized' }
+    if (!response.ok) return { status: 'unreachable', message: `HTTP ${response.status}` }
+    const payload: unknown = await response.json().catch(() => null)
+    const version = typeof payload === 'object' && payload !== null && typeof (payload as { version?: unknown }).version === 'string'
+      ? (payload as { version: string }).version
+      : null
+    return { status: 'ok', version }
+  } catch (error) {
+    return { status: 'unreachable', message: error instanceof Error ? error.message : String(error) }
+  }
+}
+
+/** Serves the one-shot pairing redeem endpoint on `0.0.0.0` and reports how it ended. */
+export async function startPairingServer(options: PairingServerOptions): Promise<PairingServerHandle> {
+  const { code, credentials, ttlMs, maxAttempts, port = 0, hostname = '0.0.0.0' } = options
+
+  let settled = false
+  let failures = 0
+  let resolveDone: (outcome: PairingOutcome) => void = () => {}
+  const done = new Promise<PairingOutcome>((resolve) => {
+    resolveDone = resolve
+  })
+
+  let closePromise: Promise<void> | undefined
+  const closeServer = (): Promise<void> => {
+    closePromise ??= new Promise<void>((resolve) => {
+      if (!server.listening) {
+        resolve()
+        return
+      }
+      server.close(() => resolve())
+    })
+    return closePromise
+  }
+
+  const timer = setTimeout(() => {
+    settle('expired')
+  }, ttlMs)
+
+  function settle(outcome: PairingOutcome): void {
+    if (settled) return
+    settled = true
+    clearTimeout(timer)
+    resolveDone(outcome)
+    void closeServer()
+  }
+
+  async function handleRequest(request: IncomingMessage, response: ServerResponse): Promise<void> {
+    const pathname = new URL(request.url ?? '/', 'http://pairing.local').pathname
+    if (settled || pathname !== REDEEM_PATH || request.method !== 'POST') {
+      sendJson(response, 404, { error: 'not found' })
+      return
+    }
+
+    const challenge = readPairingChallenge(await readJsonBody(request))
+    if (settled) {
+      sendJson(response, 404, { error: 'not found' })
+      return
+    }
+
+    if (challenge === null) {
+      rejectRequest(response, 400, 'invalid pairing request')
+      return
+    }
+
+    if (!(await verifyOpenCodePairingProof(code, challenge.nonce, challenge.proof))) {
+      rejectRequest(response, 401, 'invalid pairing proof')
+      return
+    }
+
+    let encrypted: OpenCodePairingEncryptedCredentials
+    try {
+      encrypted = await encryptOpenCodePairingCredentials({ code, nonce: challenge.nonce, credentials })
+    } catch {
+      sendJson(response, 500, { error: 'pairing encryption failed' })
+      return
+    }
+
+    if (settled) {
+      sendJson(response, 404, { error: 'not found' })
+      return
+    }
+
+    sendJson(response, 200, encrypted, () => {
+      settle('linked')
+    })
+  }
+
+  function rejectRequest(response: ServerResponse, status: number, error: string): void {
+    failures += 1
+    sendJson(response, status, { error }, failures >= maxAttempts
+      ? () => {
+          settle('rejected')
+        }
+      : undefined)
+  }
+
+  const server = createServer((request, response) => {
+    void handleRequest(request, response)
+  })
+
+  try {
+    await new Promise<void>((resolve, reject) => {
+      const onError = (error: Error) => {
+        reject(error)
+      }
+      server.once('error', onError)
+      server.listen(port, '0.0.0.0', () => {
+        server.off('error', onError)
+        resolve()
+      })
+    })
+  } catch (error) {
+    clearTimeout(timer)
+    throw error
+  }
+
+  const address = server.address()
+  const boundPort = typeof address === 'object' && address !== null ? address.port : port
+
+  return {
+    url: `http://${hostname}:${boundPort}${REDEEM_PATH}`,
+    port: boundPort,
+    done,
+    close: async () => {
+      clearTimeout(timer)
+      await closeServer()
+    },
+  }
+}
+
+interface PairingChallenge {
+  nonce: string
+  proof: string
+}
+
+function readPairingChallenge(body: unknown): PairingChallenge | null {
+  if (typeof body !== 'object' || body === null) return null
+  const { nonce, proof } = body as { nonce?: unknown; proof?: unknown }
+  if (!isOpenCodePairingNonce(nonce) || typeof proof !== 'string' || proof.length === 0) return null
+  return { nonce, proof }
+}
+
+function readJsonBody(request: IncomingMessage): Promise<unknown> {
+  return new Promise((resolve) => {
+    const chunks: Buffer[] = []
+    let size = 0
+    let finished = false
+    const finish = (value: unknown) => {
+      if (finished) return
+      finished = true
+      resolve(value)
+    }
+    request.on('data', (chunk: Buffer) => {
+      if (size > MAX_BODY_BYTES) return
+      size += chunk.length
+      if (size > MAX_BODY_BYTES) {
+        chunks.length = 0
+        return
+      }
+      chunks.push(chunk)
+    })
+    request.on('end', () => {
+      try {
+        finish(JSON.parse(Buffer.concat(chunks).toString('utf8')))
+      } catch {
+        finish(null)
+      }
+    })
+    request.on('error', () => finish(null))
+  })
+}
+
+function sendJson(response: ServerResponse, status: number, body: unknown, onFlushed?: () => void): void {
+  const payload = JSON.stringify(body)
+  response.writeHead(status, {
+    'content-type': 'application/json',
+    'content-length': Buffer.byteLength(payload),
+    connection: 'close',
+  })
+  response.end(payload, onFlushed)
+}
diff --git a/ocm-cli/src/manager-auth.ts b/ocm-cli/src/manager-auth.ts
index 5ec88dfb7..3a6cf0e40 100644
--- a/ocm-cli/src/manager-auth.ts
+++ b/ocm-cli/src/manager-auth.ts
@@ -2,6 +2,7 @@ import { readState } from './state.js'
 import { getToken, describeTokenStore } from './internal-token-store.js'
 import { TokenStoreError } from './token-store.js'
 import { ManagerApi } from './manager-api.js'
+import { trimUrlTrailingSlashes } from '@opencode-manager/shared/utils'
 
 export type ManagerAuthFailureReason = 'no-manager' | 'token-store' | 'no-token'
 
@@ -15,15 +16,11 @@ export type ResolveManagerApiResult =
   | { ok: true; auth: ManagerAuthOk; api: ManagerApi }
   | { ok: false; message: string }
 
-/** Canonical Manager URL form used as the token-store account: trimmed, without trailing slashes. */
-export function normalizeManagerUrl(url: string): string {
-  return url.trim().replace(/\/+$/, '')
-}
-
+/** Resolves the Manager URL and token used to authenticate CLI requests. */
 export async function resolveManagerAuth(
   rawManagerUrl: string | undefined = readState()?.managerUrl,
 ): Promise<ManagerAuth> {
-  const managerUrl = rawManagerUrl ? normalizeManagerUrl(rawManagerUrl) : ''
+  const managerUrl = rawManagerUrl ? trimUrlTrailingSlashes(rawManagerUrl) : ''
   if (!managerUrl) {
     return {
       ok: false,
diff --git a/ocm-cli/src/remote-context.ts b/ocm-cli/src/remote-context.ts
index 9f40ed919..1abd17b71 100644
--- a/ocm-cli/src/remote-context.ts
+++ b/ocm-cli/src/remote-context.ts
@@ -1,5 +1,5 @@
+import { trimUrlTrailingSlashes } from '@opencode-manager/shared/utils'
 import type { OcmState } from './state.js'
-import { normalizeManagerUrl } from './manager-auth.js'
 
 export const REMOTE_MANAGER_URL_ENV = 'OCM_REMOTE_MANAGER_URL'
 export const REMOTE_REPO_NAME_ENV = 'OCM_REMOTE_REPO_NAME'
@@ -43,6 +43,6 @@ export function readRemoteContext(env: NodeJS.ProcessEnv): RemoteContext | undef
 
 /** Returns the saved manager name when it belongs to the attached manager, else the manager host. */
 export function remoteDisplayName(remote: RemoteContext, state: OcmState | null): string {
-  if (state?.managerName && normalizeManagerUrl(state.managerUrl) === normalizeManagerUrl(remote.managerUrl)) return state.managerName
+  if (state?.managerName && trimUrlTrailingSlashes(state.managerUrl) === trimUrlTrailingSlashes(remote.managerUrl)) return state.managerName
   return remote.managerHost
 }
diff --git a/ocm-cli/test/link.test.ts b/ocm-cli/test/link.test.ts
new file mode 100644
index 000000000..563ee7911
--- /dev/null
+++ b/ocm-cli/test/link.test.ts
@@ -0,0 +1,172 @@
+import { describe, it, expect } from 'vitest'
+import {
+  createOpenCodePairingNonce,
+  createOpenCodePairingProof,
+  decryptOpenCodePairingCredentials,
+} from '@opencode-manager/shared/opencode'
+import { generatePairingCode, resolveDefaultBaseUrl, startPairingServer } from '../src/link'
+import type { PairingServerOptions } from '../src/link'
+import { buildOpenCodeServerLink, parseOpenCodeServerLink } from '@opencode-manager/shared/schemas'
+
+const CODE = 'test-pairing-code-0123456789abcdef'
+const CREDENTIALS = { username: 'opencode', password: 'secret-password' }
+
+function startPairing(overrides: Partial<PairingServerOptions> = {}) {
+  return startPairingServer({
+    code: CODE,
+    credentials: CREDENTIALS,
+    ttlMs: 5000,
+    maxAttempts: 3,
+    port: 0,
+    hostname: '127.0.0.1',
+    ...overrides,
+  })
+}
+
+function redeem(url: string, body: unknown, init: RequestInit = {}): Promise<Response> {
+  return fetch(url, { method: 'POST', body: JSON.stringify(body), ...init })
+}
+
+async function createChallenge(code = CODE): Promise<{ nonce: string; proof: string }> {
+  const nonce = createOpenCodePairingNonce()
+  return { nonce, proof: await createOpenCodePairingProof(code, nonce) }
+}
+
+describe('generatePairingCode', () => {
+  it('returns 32 random bytes as base64url', () => {
+    const first = generatePairingCode()
+    const second = generatePairingCode()
+
+    expect(first).toMatch(/^[A-Za-z0-9_-]{43}$/)
+    expect(second).toMatch(/^[A-Za-z0-9_-]{43}$/)
+    expect(first).not.toBe(second)
+  })
+})
+
+describe('resolveDefaultBaseUrl', () => {
+  it('uses the first non-internal IPv4 interface on port 4096', () => {
+    expect(resolveDefaultBaseUrl({
+      lo: [{ address: '127.0.0.1', family: 'IPv4', internal: true, netmask: '255.0.0.0', mac: '00:00:00:00:00:00', cidr: '127.0.0.1/8' }],
+      eth0: [{ address: '192.168.1.20', family: 'IPv4', internal: false, netmask: '255.255.255.0', mac: '00:11:22:33:44:55', cidr: '192.168.1.20/24' }],
+    })).toBe('http://192.168.1.20:4096')
+  })
+
+  it('falls back to loopback when only internal interfaces exist', () => {
+    expect(resolveDefaultBaseUrl({})).toBe('http://127.0.0.1:4096')
+  })
+})
+
+describe('startPairingServer', () => {
+  it('redeems a valid proof and returns credentials that decrypt with the code and nonce', async () => {
+    const pairing = await startPairing()
+    const challenge = await createChallenge()
+
+    const response = await redeem(pairing.url, challenge)
+    const raw = await response.text()
+
+    expect(response.status).toBe(200)
+    expect(raw).not.toContain(CREDENTIALS.password)
+    expect(raw).not.toContain(CODE)
+
+    const payload = JSON.parse(raw) as { iv: string; ciphertext: string }
+    await expect(decryptOpenCodePairingCredentials({
+      code: CODE,
+      nonce: challenge.nonce,
+      iv: payload.iv,
+      ciphertext: payload.ciphertext,
+    })).resolves.toEqual(CREDENTIALS)
+    await expect(pairing.done).resolves.toBe('linked')
+    await pairing.close()
+  })
+
+  it('rejects a wrong proof with 401 and rejects after three failures', async () => {
+    const pairing = await startPairing({ maxAttempts: 3 })
+
+    for (let attempt = 0; attempt < 3; attempt++) {
+      const response = await redeem(pairing.url, await createChallenge(`${CODE}-wrong`))
+      expect(response.status).toBe(401)
+      await expect(response.json()).resolves.toEqual({ error: 'invalid pairing proof' })
+    }
+
+    await expect(pairing.done).resolves.toBe('rejected')
+    await pairing.close()
+  })
+
+  it('rejects a malformed body with 400 and counts it as a failure', async () => {
+    const pairing = await startPairing({ maxAttempts: 1 })
+
+    const response = await redeem(pairing.url, { nonce: 'not-a-nonce', proof: 'not-a-proof' })
+
+    expect(response.status).toBe(400)
+    await expect(response.json()).resolves.toEqual({ error: 'invalid pairing request' })
+    await expect(pairing.done).resolves.toBe('rejected')
+    await pairing.close()
+  })
+
+  it('treats a missing challenge as a failed attempt', async () => {
+    const pairing = await startPairing({ maxAttempts: 1 })
+
+    const response = await redeem(pairing.url, { notA: 'challenge' })
+
+    expect(response.status).toBe(400)
+    await expect(pairing.done).resolves.toBe('rejected')
+    await pairing.close()
+  })
+
+  it('resolves expired after the ttl and stops listening', async () => {
+    const pairing = await startPairing({ ttlMs: 50 })
+
+    await expect(pairing.done).resolves.toBe('expired')
+    await expect(redeem(pairing.url, await createChallenge())).rejects.toThrow()
+    await pairing.close()
+  })
+
+  it('answers 404 for non-redeem paths and methods', async () => {
+    const pairing = await startPairing()
+
+    const otherPath = await fetch(new URL('/status', pairing.url))
+    expect(otherPath.status).toBe(404)
+    await expect(otherPath.json()).resolves.toEqual({ error: 'not found' })
+
+    const wrongMethod = await fetch(pairing.url)
+    expect(wrongMethod.status).toBe(404)
+
+    await pairing.close()
+  })
+
+  it('produces a link that parses back with the shared parser', async () => {
+    const pairing = await startPairing()
+
+    const link = buildOpenCodeServerLink({
+      kind: 'opencode',
+      name: 'build-host',
+      baseUrl: 'http://192.168.1.20:4096',
+      pairing: { pairUrl: pairing.url, code: CODE },
+    })
+
+    expect(link).toContain('v=2')
+    expect(parseOpenCodeServerLink(link)).toEqual({
+      kind: 'opencode',
+      name: 'build-host',
+      baseUrl: 'http://192.168.1.20:4096',
+      pairing: { pairUrl: `http://127.0.0.1:${pairing.port}/redeem`, code: CODE },
+    })
+
+    await pairing.close()
+  })
+
+  it('encrypts credentials under a key derived from the pairing code', async () => {
+    const pairing = await startPairing()
+    const challenge = await createChallenge()
+
+    const payload = await redeem(pairing.url, challenge).then((response) => response.json()) as { iv: string; ciphertext: string }
+
+    await expect(decryptOpenCodePairingCredentials({
+      code: `${CODE}-other`,
+      nonce: challenge.nonce,
+      iv: payload.iv,
+      ciphertext: payload.ciphertext,
+    })).rejects.toThrow()
+    await pairing.close()
+  })
+})
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index b3b52e5c4..6501e98a6 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -183,6 +183,9 @@ importers:
       diff:
         specifier: ^8.0.2
         version: 8.0.2
+      jsqr:
+        specifier: ^1.4.0
+        version: 1.4.0
       lucide-react:
         specifier: ^0.546.0
         version: 0.546.0(react@19.2.3)
@@ -325,6 +328,9 @@ importers:
       typescript-eslint:
         specifier: ^8.45.0
         version: 8.51.0(eslint@9.39.2(jiti@2.6.1))(typescript@5.9.3)
+      uqr:
+        specifier: ^0.1.3
+        version: 0.1.3
       vitest:
         specifier: ^3.1.0
         version: 3.2.4(@types/debug@4.1.12)(@types/node@22.19.19)(@vitest/ui@3.2.4)(jiti@2.6.1)(jsdom@27.4.0)(lightningcss@1.30.2)(terser@5.46.0)(yaml@2.9.0)
@@ -3880,6 +3886,9 @@ packages:
     resolution: {integrity: sha512-POQXvpdL69+CluYsillJ7SUhKvytYjW9vG/GKpnf+xP8UWgYEM/RaMzHHofbALDiKbbP1W8UEYmgGl39WkPZsg==}
     engines: {'0': node >= 0.2.0}
 
+  jsqr@1.4.0:
+    resolution: {integrity: sha512-dxLob7q65Xg2DvstYkRpkYtmKm2sPJ9oFhrhmudT1dZvNFFTlroai3AWSpLey/w5vMcLBXRgOJsbXpdN9HzU/A==}
+
   just-diff-apply@5.5.0:
     resolution: {integrity: sha512-OYTthRfSh55WOItVqwpefPtNt2VdKsq5AnAK6apdtR6yCH8pr0CmSr710J0Mf+WdQy7K/OzMy7K2MgAfdQURDw==}
 
@@ -5144,6 +5153,9 @@ packages:
     peerDependencies:
       browserslist: '>= 4.21.0'
 
+  uqr@0.1.3:
+    resolution: {integrity: sha512-0rjE8iEJe4YmT9TOhwsZtqCMRLc5DXZUI2UEYUUg63ikBkqqE5EYWaI0etFe/5KUcmcYwLih2RND1kq+hrUJXA==}
+
   uri-js@4.4.1:
     resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==}
 
@@ -9341,6 +9353,8 @@ snapshots:
 
   jsonparse@1.3.1: {}
 
+  jsqr@1.4.0: {}
+
   just-diff-apply@5.5.0: {}
 
   just-diff@6.0.2: {}
@@ -10949,6 +10963,8 @@ snapshots:
       escalade: 3.2.0
       picocolors: 1.1.1
 
+  uqr@0.1.3: {}
+
   uri-js@4.4.1:
     dependencies:
       punycode: 2.3.1
diff --git a/shared/src/opencode/index.ts b/shared/src/opencode/index.ts
index 3333b8768..14c3b09ae 100644
--- a/shared/src/opencode/index.ts
+++ b/shared/src/opencode/index.ts
@@ -1,4 +1,7 @@
 import { OpenCode } from '@opencode/client'
+import { OPENCODE_SERVER_USERNAME } from '../schemas/opencode-servers'
+
+export { OPENCODE_SERVER_USERNAME }
 
 export type {
   AgentInfo,
@@ -92,6 +95,23 @@ export type {
   McpTimeoutConfig,
 } from './mcp'
 
+export {
+  createOpenCodePairingNonce,
+  createOpenCodePairingProof,
+  decryptOpenCodePairingCredentials,
+  encryptOpenCodePairingCredentials,
+  isOpenCodePairingCredentials,
+  isOpenCodePairingNonce,
+  verifyOpenCodePairingProof,
+} from './pairing'
+
+export type {
+  OpenCodePairingCredentials,
+  OpenCodePairingDecryptOptions,
+  OpenCodePairingEncryptedCredentials,
+  OpenCodePairingKeyOptions,
+} from './pairing'
+
 export {
   OPENCODE_PINNED_VERSION,
   OPENCODE_SUPPORTED_VERSION_RANGE,
@@ -109,8 +129,6 @@ export { OPENCODE_LIFECYCLE_STATES, OPENCODE_RECOVERY_ACTIONS } from './lifecycl
 
 export type { OpenCodeLifecycleState, OpenCodeLifecycleStatus, OpenCodeRecoveryAction } from './lifecycle'
 
-export const OPENCODE_SERVER_USERNAME = 'opencode'
-
 export type OpenCodeApi = ReturnType<typeof OpenCode.make>
 
 export interface OpenCodeApiOptions {
@@ -120,8 +138,8 @@ export interface OpenCodeApiOptions {
   headers?: Record<string, string>
 }
 
-export function buildOpenCodeBasicAuth(password: string): string {
-  const bytes = new TextEncoder().encode(`${OPENCODE_SERVER_USERNAME}:${password}`)
+export function buildOpenCodeBasicAuth(password: string, username: string = OPENCODE_SERVER_USERNAME): string {
+  const bytes = new TextEncoder().encode(`${username}:${password}`)
   let binary = ''
   for (const byte of bytes) binary += String.fromCharCode(byte)
   return `Basic ${btoa(binary)}`
diff --git a/shared/src/opencode/pairing.ts b/shared/src/opencode/pairing.ts
new file mode 100644
index 000000000..b03dc29fc
--- /dev/null
+++ b/shared/src/opencode/pairing.ts
@@ -0,0 +1,168 @@
+const PAIRING_PROTOCOL = 'ocm-pair-v2'
+const PAIRING_PROOF_PREFIX = `${PAIRING_PROTOCOL}:`
+const PAIRING_KEY_INFO = `${PAIRING_PROTOCOL} credentials`
+const PAIRING_NONCE_BYTES = 32
+const PAIRING_IV_BYTES = 12
+const PAIRING_KEY_BITS = 256
+
+const textEncoder = new TextEncoder()
+const textDecoder = new TextDecoder()
+
+type WebCryptoKey = Awaited<ReturnType<typeof globalThis.crypto.subtle.importKey>>
+
+export interface OpenCodePairingCredentials {
+  username: string
+  password: string
+}
+
+export interface OpenCodePairingEncryptedCredentials {
+  iv: string
+  ciphertext: string
+}
+
+export interface OpenCodePairingKeyOptions {
+  code: string
+  nonce: string
+}
+
+export interface OpenCodePairingDecryptOptions extends OpenCodePairingKeyOptions {
+  iv: string
+  ciphertext: string
+}
+
+/** Generates a fresh 32-byte pairing nonce encoded as base64url. */
+export function createOpenCodePairingNonce(): string {
+  return base64UrlEncode(globalThis.crypto.getRandomValues(new Uint8Array(PAIRING_NONCE_BYTES)))
+}
+
+/** Reports whether a value is a base64url-encoded 32-byte pairing nonce. */
+export function isOpenCodePairingNonce(value: unknown): value is string {
+  if (typeof value !== 'string') return false
+  const bytes = base64UrlDecode(value)
+  return bytes !== null && bytes.length === PAIRING_NONCE_BYTES
+}
+
+/** Reports whether a value carries non-empty string credentials. */
+export function isOpenCodePairingCredentials(value: unknown): value is OpenCodePairingCredentials {
+  if (typeof value !== 'object' || value === null) return false
+  const { username, password } = value as { username?: unknown; password?: unknown }
+  return typeof username === 'string' && username.length > 0 && typeof password === 'string'
+}
+
+/** Computes the base64url HMAC-SHA256 proof that binds a pairing code to a nonce. */
+export async function createOpenCodePairingProof(code: string, nonce: string): Promise<string> {
+  const key = await importHmacKey(code)
+  const signature = await globalThis.crypto.subtle.sign('HMAC', key, pairingProofMessage(nonce))
+  return base64UrlEncode(new Uint8Array(signature))
+}
+
+/** Verifies a pairing proof in constant time through the Web Crypto HMAC verifier. */
+export async function verifyOpenCodePairingProof(code: string, nonce: string, proof: string): Promise<boolean> {
+  const signature = base64UrlDecode(proof)
+  if (signature === null) return false
+  const key = await importHmacKey(code)
+  try {
+    return await globalThis.crypto.subtle.verify('HMAC', key, signature, pairingProofMessage(nonce))
+  } catch {
+    return false
+  }
+}
+
+/** Encrypts pairing credentials with AES-256-GCM under a key derived from the code and nonce. */
+export async function encryptOpenCodePairingCredentials(
+  options: OpenCodePairingKeyOptions & { credentials: OpenCodePairingCredentials },
+): Promise<OpenCodePairingEncryptedCredentials> {
+  const key = await deriveCredentialsKey(options.code, options.nonce)
+  const iv = globalThis.crypto.getRandomValues(new Uint8Array(PAIRING_IV_BYTES))
+  const plaintext = encodeText(JSON.stringify({
+    username: options.credentials.username,
+    password: options.credentials.password,
+  }))
+  const ciphertext = await globalThis.crypto.subtle.encrypt(
+    { name: 'AES-GCM', iv, additionalData: pairingAdditionalData() },
+    key,
+    plaintext,
+  )
+  return {
+    iv: base64UrlEncode(iv),
+    ciphertext: base64UrlEncode(new Uint8Array(ciphertext)),
+  }
+}
+
+/** Decrypts pairing credentials, throwing when the payload is tampered with or malformed. */
+export async function decryptOpenCodePairingCredentials(
+  options: OpenCodePairingDecryptOptions,
+): Promise<OpenCodePairingCredentials> {
+  const iv = base64UrlDecode(options.iv)
+  const ciphertext = base64UrlDecode(options.ciphertext)
+  if (iv === null || iv.length !== PAIRING_IV_BYTES || ciphertext === null) {
+    throw new Error('Invalid pairing payload')
+  }
+  const key = await deriveCredentialsKey(options.code, options.nonce)
+  const plaintext = await globalThis.crypto.subtle.decrypt(
+    { name: 'AES-GCM', iv, additionalData: pairingAdditionalData() },
+    key,
+    ciphertext,
+  )
+  const parsed: unknown = JSON.parse(textDecoder.decode(plaintext))
+  if (!isOpenCodePairingCredentials(parsed)) throw new Error('Invalid pairing payload')
+  return parsed
+}
+
+function encodeText(value: string): Uint8Array<ArrayBuffer> {
+  return new Uint8Array(textEncoder.encode(value))
+}
+
+function pairingProofMessage(nonce: string): Uint8Array<ArrayBuffer> {
+  return encodeText(`${PAIRING_PROOF_PREFIX}${nonce}`)
+}
+
+function pairingAdditionalData(): Uint8Array<ArrayBuffer> {
+  return encodeText(PAIRING_PROTOCOL)
+}
+
+async function importHmacKey(code: string): Promise<WebCryptoKey> {
+  return globalThis.crypto.subtle.importKey(
+    'raw',
+    encodeText(code),
+    { name: 'HMAC', hash: 'SHA-256' },
+    false,
+    ['sign', 'verify'],
+  )
+}
+
+async function deriveCredentialsKey(code: string, nonce: string): Promise<WebCryptoKey> {
+  const keyMaterial = await globalThis.crypto.subtle.importKey('raw', encodeText(code), 'HKDF', false, ['deriveKey'])
+  return globalThis.crypto.subtle.deriveKey(
+    {
+      name: 'HKDF',
+      hash: 'SHA-256',
+      salt: encodeText(nonce),
+      info: encodeText(PAIRING_KEY_INFO),
+    },
+    keyMaterial,
+    { name: 'AES-GCM', length: PAIRING_KEY_BITS },
+    false,
+    ['encrypt', 'decrypt'],
+  )
+}
+
+function base64UrlEncode(bytes: Uint8Array): string {
+  let binary = ''
+  for (const byte of bytes) binary += String.fromCharCode(byte)
+  return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
+}
+
+function base64UrlDecode(value: string): Uint8Array<ArrayBuffer> | null {
+  if (!/^[A-Za-z0-9_-]+={0,2}$/.test(value)) return null
+  const base64 = value.replace(/-/g, '+').replace(/_/g, '/').replace(/=+$/, '')
+  const padded = base64 + '='.repeat((4 - (base64.length % 4)) % 4)
+  try {
+    const binary = atob(padded)
+    const bytes = new Uint8Array(binary.length)
+    for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index)
+    return bytes
+  } catch {
+    return null
+  }
+}
diff --git a/shared/src/schemas/index.ts b/shared/src/schemas/index.ts
index f2e665929..63c511dd7 100644
--- a/shared/src/schemas/index.ts
+++ b/shared/src/schemas/index.ts
@@ -23,3 +23,4 @@ export * from './terminal'
 export * from './project-config'
 export * from './preview'
 export * from './change-walkthroughs'
+export * from './opencode-servers'
diff --git a/shared/src/schemas/opencode-servers.ts b/shared/src/schemas/opencode-servers.ts
new file mode 100644
index 000000000..5072e0dd7
--- /dev/null
+++ b/shared/src/schemas/opencode-servers.ts
@@ -0,0 +1,144 @@
+import { z } from "zod";
+
+export const LOCAL_OPENCODE_SERVER_ID = "local";
+export const OPENCODE_SERVER_USERNAME = "opencode";
+export const OPENCODE_SERVER_LINK_PROTOCOL = "ocm:";
+export const OPENCODE_SERVER_LINK_VERSION = "2";
+
+const HttpUrlSchema = z
+  .string()
+  .trim()
+  .url()
+  .refine((value) => /^https?:\/\//i.test(value), "URL must start with http:// or https://");
+
+export const OpenCodeServerSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  baseUrl: z.string(),
+  username: z.string(),
+  enabled: z.boolean(),
+  hasPassword: z.boolean(),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+});
+
+export const OpenCodeServerPairingSchema = z.object({
+  pairUrl: HttpUrlSchema,
+  code: z.string().min(16).max(256),
+});
+
+export const CreateOpenCodeServerRequestSchema = z
+  .object({
+    name: z.string().trim().min(1).max(100),
+    baseUrl: HttpUrlSchema,
+    username: z.string().trim().min(1).max(100).default(OPENCODE_SERVER_USERNAME),
+    password: z.string().min(1).max(1024).optional(),
+    pairing: OpenCodeServerPairingSchema.optional(),
+    enabled: z.boolean().default(true),
+  })
+  .refine((value) => !(value.password && value.pairing), "Provide either a password or a pairing code, not both");
+
+export const UpdateOpenCodeServerRequestSchema = z
+  .object({
+    name: z.string().trim().min(1).max(100).optional(),
+    baseUrl: HttpUrlSchema.optional(),
+    username: z.string().trim().min(1).max(100).optional(),
+    password: z.string().min(1).max(1024).nullable().optional(),
+    pairing: OpenCodeServerPairingSchema.optional(),
+    enabled: z.boolean().optional(),
+  })
+  .refine((value) => !(value.password && value.pairing), "Provide either a password or a pairing code, not both");
+
+export const TestOpenCodeServerRequestSchema = z.object({
+  baseUrl: HttpUrlSchema,
+  username: z.string().trim().min(1).max(100).default(OPENCODE_SERVER_USERNAME),
+  password: z.string().max(1024).optional(),
+  serverId: z.string().trim().min(1).optional(),
+});
+
+export const OpenCodeServerTestResultSchema = z.object({
+  ok: z.boolean(),
+  version: z.string().nullable(),
+  versionSupported: z.boolean(),
+  error: z.string().nullable(),
+});
+
+export const OpenCodeServerStatusSchema = z.object({
+  serverId: z.string(),
+  connected: z.boolean(),
+  version: z.string().nullable(),
+  error: z.string().nullable(),
+});
+
+export const OpenCodeServerLinkSchema = z.object({
+  kind: z.literal("opencode"),
+  name: z.string().trim().min(1).max(100),
+  baseUrl: HttpUrlSchema,
+  pairing: OpenCodeServerPairingSchema,
+});
+
+export type OpenCodeServer = z.infer<typeof OpenCodeServerSchema>;
+export type OpenCodeServerPairing = z.infer<typeof OpenCodeServerPairingSchema>;
+export type CreateOpenCodeServerRequest = z.input<typeof CreateOpenCodeServerRequestSchema>;
+export type UpdateOpenCodeServerRequest = z.input<typeof UpdateOpenCodeServerRequestSchema>;
+export type TestOpenCodeServerRequest = z.input<typeof TestOpenCodeServerRequestSchema>;
+export type OpenCodeServerTestResult = z.infer<typeof OpenCodeServerTestResultSchema>;
+export type OpenCodeServerStatus = z.infer<typeof OpenCodeServerStatusSchema>;
+export type OpenCodeServerLink = z.infer<typeof OpenCodeServerLinkSchema>;
+
+/** Builds the `ocm://link` URL encoded into a pairing QR code. */
+export function buildOpenCodeServerLink(link: OpenCodeServerLink): string {
+  const params = new URLSearchParams({
+    v: OPENCODE_SERVER_LINK_VERSION,
+    kind: link.kind,
+    name: link.name,
+    url: link.baseUrl,
+    pair: link.pairing.pairUrl,
+    code: link.pairing.code,
+  });
+  return `${OPENCODE_SERVER_LINK_PROTOCOL}//link?${params.toString()}`;
+}
+
+/** Parses an `ocm://link` URL from a QR code or pasted text; returns null when it is not a valid link. */
+export function parseOpenCodeServerLink(text: string): OpenCodeServerLink | null {
+  const url = parseOpenCodeServerLinkUrl(text);
+  if (!url) return null;
+  if (url.searchParams.get("v") !== OPENCODE_SERVER_LINK_VERSION) return null;
+
+  const parsed = OpenCodeServerLinkSchema.safeParse({
+    kind: url.searchParams.get("kind"),
+    name: url.searchParams.get("name"),
+    baseUrl: url.searchParams.get("url"),
+    pairing: { pairUrl: url.searchParams.get("pair"), code: url.searchParams.get("code") },
+  });
+  return parsed.success ? parsed.data : null;
+}
+
+/** Reads the `v` parameter of an `ocm://link` URL, or null when the text is not an `ocm://link` URL. */
+export function readOpenCodeServerLinkVersion(text: string): string | null {
+  return parseOpenCodeServerLinkUrl(text)?.searchParams.get("v") ?? null;
+}
+
+function parseOpenCodeServerLinkUrl(text: string): URL | null {
+  let url: URL;
+  try {
+    url = new URL(text.trim());
+  } catch {
+    return null;
+  }
+  if (url.protocol !== OPENCODE_SERVER_LINK_PROTOCOL || url.hostname !== "link") return null;
+  return url;
+}
+
+const REMOTE_DIRECTORY_KEY_PATTERN = /^(srv_[A-Za-z0-9_-]+)\|(.+)$/s;
+
+/** Builds the event-stream subscription key for a directory; local directories stay unchanged. */
+export function buildServerDirectoryKey(serverId: string, directory: string): string {
+  return serverId === LOCAL_OPENCODE_SERVER_ID ? directory : `${serverId}|${directory}`;
+}
+
+/** Splits an event-stream subscription key into its server id and directory. */
+export function parseServerDirectoryKey(key: string): { serverId: string; directory: string } {
+  const match = REMOTE_DIRECTORY_KEY_PATTERN.exec(key);
+  return match?.[1] && match[2] ? { serverId: match[1], directory: match[2] } : { serverId: LOCAL_OPENCODE_SERVER_ID, directory: key };
+}
diff --git a/shared/src/schemas/sse.ts b/shared/src/schemas/sse.ts
index 5f5296250..af21d71e3 100644
--- a/shared/src/schemas/sse.ts
+++ b/shared/src/schemas/sse.ts
@@ -17,5 +17,6 @@ export type SSEVisibilityRequest = z.infer<typeof SSEVisibilitySchema>;
 
 export interface SSEEventEnvelope {
   directory?: string | null;
+  serverId?: string;
   payload: V2Event;
 }
diff --git a/shared/src/utils/index.ts b/shared/src/utils/index.ts
index 3cedb3b6d..9c5233b51 100644
--- a/shared/src/utils/index.ts
+++ b/shared/src/utils/index.ts
@@ -5,3 +5,4 @@ export * from './sandbox-command'
 export * from './semver'
 export * from './terminal-title'
 export * from './unified-diff'
+export * from './url'
diff --git a/shared/src/utils/url.ts b/shared/src/utils/url.ts
new file mode 100644
index 000000000..0c798b43c
--- /dev/null
+++ b/shared/src/utils/url.ts
@@ -0,0 +1,18 @@
+/** Trims a URL and removes its trailing slashes. */
+export function trimUrlTrailingSlashes(url: string): string {
+  return url.trim().replace(/\/+$/, '')
+}
+
+/** Reports whether two URLs share the same origin; false when either URL is invalid. */
+export function haveSameUrlOrigin(first: string, second: string): boolean {
+  const origin = readUrlOrigin(first)
+  return origin !== null && origin === readUrlOrigin(second)
+}
+
+function readUrlOrigin(value: string): string | null {
+  try {
+    return new URL(value).origin
+  } catch {
+    return null
+  }
+}