diff --git a/packages/server/src/api-types.ts b/packages/server/src/api-types.ts
index d591dba44..61d1ddb3f 100644
--- a/packages/server/src/api-types.ts
+++ b/packages/server/src/api-types.ts
@@ -14,6 +14,73 @@ import type {
 
 export type WorkspaceStatus = "starting" | "ready" | "stopped" | "error"
 
+export type ExecutionProfileKind = "local" | "wsl" | "docker" | "command" | "ssh"
+export type ExecutionProfileCwdMode = "workspace" | "inherit"
+
+export interface ExecutionProfileBase {
+  id: string
+  name: string
+  kind: ExecutionProfileKind
+}
+
+export interface LocalExecutionProfile extends ExecutionProfileBase {
+  kind: "local"
+  binaryPath: string
+}
+
+export interface WslExecutionProfile extends ExecutionProfileBase {
+  kind: "wsl"
+  distro: string
+  binaryPath: string
+}
+
+export interface DockerExecutionProfile extends ExecutionProfileBase {
+  kind: "docker"
+  image: string
+  workspaceMountPath: string
+  configMountPath: string
+  command?: string[]
+  extraDockerArgs?: string[]
+}
+
+export interface CommandExecutionProfile extends ExecutionProfileBase {
+  kind: "command"
+  executable: string
+  args?: string[]
+  cwdMode?: ExecutionProfileCwdMode
+}
+
+export interface SshExecutionProfile extends ExecutionProfileBase {
+  kind: "ssh"
+  host: string
+  port?: number
+  username?: string
+  remotePath: string
+  binaryPath: string
+  args?: string[]
+}
+
+export type ExecutionProfile = LocalExecutionProfile | WslExecutionProfile | DockerExecutionProfile | CommandExecutionProfile | SshExecutionProfile
+
+export interface ExecutionProfilePreviewRequest {
+  profile: ExecutionProfile
+  workspacePath?: string
+}
+
+export interface ExecutionProfilePreviewResponse {
+  command: string
+  args: string[]
+  commandLine: string
+  cwd?: string
+  environment: Record<string, string>
+}
+
+export interface ExecutionProfileTestResponse extends ExecutionProfilePreviewResponse {
+  valid: boolean
+  version?: string
+  error?: string
+}
+
 export interface WorkspaceDescriptor {
   id: string
   /** Absolute path on the server host. */
@@ -29,6 +96,9 @@ export interface WorkspaceDescriptor {
   binaryId: string
   binaryLabel: string
   binaryVersion?: string
+  executionProfileId?: string
+  executionProfileName?: string
+  executionProfileKind?: ExecutionProfileKind
   createdAt: string
   updatedAt: string
   /** Present when `status` is "error". */
@@ -38,6 +108,7 @@ export interface WorkspaceDescriptor {
 export interface WorkspaceCreateRequest {
   path: string
   name?: string
+  executionProfileId?: string
 }
 
 export interface WorkspaceCloneRequest {
diff --git a/packages/server/src/opencode-plugin.test.ts b/packages/server/src/opencode-plugin.test.ts
index dda5f9881..a0a5705fd 100644
--- a/packages/server/src/opencode-plugin.test.ts
+++ b/packages/server/src/opencode-plugin.test.ts
@@ -1,7 +1,11 @@
 import assert from "node:assert/strict"
 import { describe, it } from "node:test"
 
-import { buildOpencodeConfigContent } from "./opencode-plugin"
+import {
+  buildOpencodeConfigContent,
+  findPackagedCodeNomadPluginReference,
+  rewritePackagedCodeNomadPluginReference,
+} from "./opencode-plugin"
 
 describe("buildOpencodeConfigContent", () => {
   it("creates config content with the CodeNomad plugin", () => {
@@ -35,4 +39,37 @@ describe("buildOpencodeConfigContent", () => {
 
     assert.deepEqual(JSON.parse(content).plugin, ["file:///plugin.tgz"])
   })
+
+  it("finds the packaged CodeNomad plugin tarball reference", () => {
+    const reference = findPackagedCodeNomadPluginReference(`{
+      "plugin": [
+        "npm:user-plugin",
+        "@codenomad/codenomad-opencode-plugin@file:C:/Users/dev/AppData/Roaming/CodeNomad/codenomad-opencode-plugin.tgz"
+      ]
+    }`)
+
+    assert.deepEqual(reference, {
+      specifier: "@codenomad/codenomad-opencode-plugin@file:C:/Users/dev/AppData/Roaming/CodeNomad/codenomad-opencode-plugin.tgz",
+      filePath: "C:/Users/dev/AppData/Roaming/CodeNomad/codenomad-opencode-plugin.tgz",
+    })
+  })
+
+  it("rewrites the packaged CodeNomad plugin tarball reference", () => {
+    const content = rewritePackagedCodeNomadPluginReference(
+      `{
+        "plugin": [
+          "npm:user-plugin",
+          "@codenomad/codenomad-opencode-plugin@file:C:/Users/dev/AppData/Roaming/CodeNomad/codenomad-opencode-plugin.tgz"
+        ]
+      }`,
+      "/tmp/codenomad-opencode-plugin.tgz",
+    )
+
+    assert.deepEqual(JSON.parse(content), {
+      plugin: [
+        "npm:user-plugin",
+        "@codenomad/codenomad-opencode-plugin@file:/tmp/codenomad-opencode-plugin.tgz",
+      ],
+    })
+  })
 })
diff --git a/packages/server/src/opencode-plugin.ts b/packages/server/src/opencode-plugin.ts
index 761292da5..1889f4732 100644
--- a/packages/server/src/opencode-plugin.ts
+++ b/packages/server/src/opencode-plugin.ts
@@ -68,6 +68,49 @@ export function resolveExistingOpencodeConfigContent(userEnvironment: Record<str
   return normalizeConfigContentValue(process.env.OPENCODE_CONFIG_CONTENT)
 }
 
+export function findPackagedCodeNomadPluginReference(configContent: string | undefined): { specifier: string; filePath: string } | null {
+  if (!configContent?.trim()) {
+    return null
+  }
+
+  const config = parseJsoncObject(configContent)
+  for (const entry of normalizePluginEntries(config.plugin)) {
+    const reference = parsePackagedPluginSpecifier(entry)
+    if (reference) {
+      return reference
+    }
+  }
+
+  return null
+}
+
+export function rewritePackagedCodeNomadPluginReference(configContent: string, filePath: string): string {
+  const config = parseJsoncObject(configContent)
+  let changed = false
+  const nextPluginEntries = normalizePluginEntries(config.plugin).map((entry) => {
+    const reference = parsePackagedPluginSpecifier(entry)
+    if (!reference) {
+      return entry
+    }
+
+    changed = true
+    return toNpmFileSpecifier(filePath)
+  })
+
+  if (!changed) {
+    return configContent
+  }
+
+  return JSON.stringify(
+    {
+      ...config,
+      plugin: typeof config.plugin === "string" ? nextPluginEntries[0] ?? toNpmFileSpecifier(filePath) : nextPluginEntries,
+    },
+    null,
+    2,
+  )
+}
+
 function toNpmFileSpecifier(filePath: string): string {
   return `${pluginPackageName}@file:${filePath.replace(/\\/g, "/")}`
 }
@@ -87,6 +130,20 @@ function normalizeConfigContentValue(value: unknown): string | undefined {
   return typeof value === "string" && value.trim().length > 0 ? value : undefined
 }
 
+function parsePackagedPluginSpecifier(value: string): { specifier: string; filePath: string } | null {
+  const prefix = `${pluginPackageName}@file:`
+  if (!value.startsWith(prefix)) {
+    return null
+  }
+
+  const filePath = value.slice(prefix.length).trim()
+  if (!filePath.endsWith(".tgz")) {
+    return null
+  }
+
+  return { specifier: value, filePath }
+}
+
 function parseJsoncObject(content: string): Record<string, unknown> {
   try {
     const parsed = JSON.parse(stripJsonc(content))
diff --git a/packages/server/src/server/http-server.ts b/packages/server/src/server/http-server.ts
index faa53d3fd..ba3858922 100644
--- a/packages/server/src/server/http-server.ts
+++ b/packages/server/src/server/http-server.ts
@@ -75,6 +75,16 @@ interface HttpServerStartResult {
   displayHost: string
 }
 
+function redactSensitivePayload(value: unknown): unknown {
+  if (!value || typeof value !== "object") return value
+  if (Array.isArray(value)) return value.map(redactSensitivePayload)
+  const output: Record<string, unknown> = {}
+  for (const [key, entry] of Object.entries(value as Record<string, unknown>)) {
+    output[key] = /(PASSWORD|TOKEN|SECRET|API[_-]?KEY)/i.test(key) ? "[REDACTED]" : redactSensitivePayload(entry)
+  }
+  return output
+}
+
 export function createHttpServer(deps: HttpServerDeps) {
   // Fastify's type-level RawServer inference gets noisy when toggling HTTP vs HTTPS.
   // We keep the runtime behavior correct and cast the instance to a generic FastifyInstance.
@@ -118,7 +128,8 @@ export function createHttpServer(deps: HttpServerDeps) {
     }
     apiLogger.debug(base, "HTTP request completed")
     if (apiLogger.isLevelEnabled("trace")) {
-      apiLogger.trace({ ...base, params: request.params, query: request.query, body: request.body }, "HTTP request payload")
+      const body = redactSensitivePayload(request.body)
+      apiLogger.trace({ ...base, params: request.params, query: request.query, body }, "HTTP request payload")
     }
     done()
   })
@@ -695,7 +706,7 @@ async function proxyWorkspaceRequest(args: {
 
   logger.debug({ workspaceId, method: request.method, targetUrl }, "Proxying request to instance")
   if (logger.isLevelEnabled("trace")) {
-    logger.trace({ workspaceId, targetUrl, body: request.body }, "Instance proxy payload")
+    logger.trace({ workspaceId, targetUrl, body: redactSensitivePayload(request.body) }, "Instance proxy payload")
   }
 
   return reply.from(targetUrl, {
@@ -733,7 +744,7 @@ async function proxyWorkspaceRequest(args: {
             worktreeSlug,
             directory,
             contentType: request.headers["content-type"],
-            body: bodyToJson(request.body),
+            body: redactSensitivePayload(bodyToJson(request.body)),
             headers: outgoing,
           },
           "Proxy -> OpenCode request",
diff --git a/packages/server/src/server/routes/settings.ts b/packages/server/src/server/routes/settings.ts
index 5d18e4fd5..1fe77c036 100644
--- a/packages/server/src/server/routes/settings.ts
+++ b/packages/server/src/server/routes/settings.ts
@@ -1,5 +1,19 @@
-import { FastifyInstance } from "fastify"
+import { spawnSync } from "child_process"
+import { FastifyInstance, type FastifyRequest } from "fastify"
 import { z } from "zod"
+import type { ExecutionProfilePreviewResponse, ExecutionProfileTestResponse } from "../../api-types"
+import {
+  buildOpencodeConfigContent,
+  getCodeNomadPluginUrl,
+  resolveExistingOpencodeConfigContent,
+} from "../../opencode-plugin.js"
+import { buildLaunchPreview, formatCommandLine } from "../../workspaces/execution-launch"
+import {
+  OPENCODE_SERVER_BASE_URL_ENV,
+  OPENCODE_SERVER_PASSWORD_ENV,
+  OPENCODE_SERVER_USERNAME_ENV,
+  resolveOpencodeServerAuth,
+} from "../../workspaces/opencode-auth"
 import { probeBinaryVersion } from "../../workspaces/spawn"
 import type { SettingsService } from "../../settings/service"
 import type { Logger } from "../../logger"
@@ -14,11 +28,275 @@ const ValidateBinarySchema = z.object({
   path: z.string(),
 })
 
-function validateBinaryPath(binaryPath: string): { valid: boolean; version?: string; error?: string } {
-  const result = probeBinaryVersion(binaryPath)
+const ExecutionProfileSchema = z.discriminatedUnion("kind", [
+  z.object({
+    id: z.string().trim().min(1),
+    name: z.string().trim().min(1),
+    kind: z.literal("local"),
+    binaryPath: z.string().trim().min(1),
+  }),
+  z.object({
+    id: z.string().trim().min(1),
+    name: z.string().trim().min(1),
+    kind: z.literal("wsl"),
+    distro: z.string().trim().min(1),
+    binaryPath: z.string().trim().min(1),
+  }),
+  z.object({
+    id: z.string().trim().min(1),
+    name: z.string().trim().min(1),
+    kind: z.literal("docker"),
+    image: z.string().trim().min(1),
+    workspaceMountPath: z.string().trim().min(1),
+    configMountPath: z.string().trim().min(1),
+    command: z.array(z.string().trim().min(1)).optional(),
+    extraDockerArgs: z.array(z.string().trim().min(1)).optional(),
+  }),
+  z.object({
+    id: z.string().trim().min(1),
+    name: z.string().trim().min(1),
+    kind: z.literal("command"),
+    executable: z.string().trim().min(1),
+    args: z.array(z.string().trim().min(1)).optional(),
+    cwdMode: z.enum(["workspace", "inherit"]).optional(),
+  }),
+  z.object({
+    id: z.string().trim().min(1),
+    name: z.string().trim().min(1),
+    kind: z.literal("ssh"),
+    host: z.string().trim().min(1),
+    port: z.number().int().positive().max(65535).optional(),
+    username: z.string().trim().optional(),
+    remotePath: z.string().trim().min(1),
+    binaryPath: z.string().trim().min(1),
+    args: z.array(z.string().trim().min(1)).optional(),
+  }),
+])
+
+const ExecutionProfilePreviewSchema = z.object({
+  profile: ExecutionProfileSchema,
+  workspacePath: z.string().trim().optional(),
+})
+
+const PREVIEW_SECRET_KEY = /(PASSWORD|TOKEN|SECRET|API[_-]?KEY)/i
+
+function validateBinaryPath(binaryPath: string, options: { wslDistro?: string } = {}): { valid: boolean; version?: string; error?: string } {
+  const result = probeBinaryVersion(binaryPath, options)
   return { valid: result.valid, version: result.version, error: result.error }
 }
 
+function validateDockerImage(image: string): { valid: boolean; version?: string; error?: string } {
+  const docker = validateBinaryPath("docker")
+  if (!docker.valid) {
+    return docker
+  }
+
+  try {
+    const result = spawnSync("docker", ["image", "inspect", image], { encoding: "utf8" })
+    if (result.error) {
+      return { valid: false, version: docker.version, error: result.error.message }
+    }
+
+    if (result.status !== 0) {
+      const stderr = result.stderr?.trim()
+      const stdout = result.stdout?.trim()
+      const combined = stderr || stdout
+      const details = combined ? `: ${combined}` : ""
+      return {
+        valid: false,
+        version: docker.version,
+        error: `Docker image \"${image}\" is not available locally${details}`,
+      }
+    }
+
+    return { valid: true, version: docker.version }
+  } catch (error) {
+    return { valid: false, version: docker.version, error: error instanceof Error ? error.message : String(error) }
+  }
+}
+
+function normalizeRecord(value: unknown): Record<string, string> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {}
+  }
+
+  const output: Record<string, string> = {}
+  for (const [key, entry] of Object.entries(value as Record<string, unknown>)) {
+    if (typeof entry !== "string") {
+      continue
+    }
+    const trimmed = entry.trim()
+    if (trimmed) {
+      output[key] = trimmed
+    }
+  }
+
+  return output
+}
+
+function readConfiguredServerEnvironment(settings: SettingsService): Record<string, string> {
+  const serverConfig = settings.getOwner("config", "server")
+  return normalizeRecord((serverConfig as any)?.environmentVariables)
+}
+
+function readConfiguredLogLevel(settings: SettingsService): string {
+  const serverConfig = settings.getOwner("config", "server")
+  const logLevel = (serverConfig as any)?.logLevel
+  return typeof logLevel === "string" && logLevel.trim() ? logLevel.toUpperCase() : "DEBUG"
+}
+
+function redactPreviewEnvironment(environment: Record<string, string>): Record<string, string> {
+  const redacted: Record<string, string> = {}
+  for (const [key, value] of Object.entries(environment)) {
+    redacted[key] = PREVIEW_SECRET_KEY.test(key) ? "REDACTED" : value
+  }
+  return redacted
+}
+
+function redactPreviewArgs(args: string[]): string[] {
+  return args.map((arg, index) => {
+    const [key] = arg.split("=", 1)
+    if (key && PREVIEW_SECRET_KEY.test(key)) {
+      return arg.includes("=") ? `${key}=REDACTED` : "REDACTED"
+    }
+
+    const previous = args[index - 1]
+    if ((previous === "-e" || previous === "--env") && PREVIEW_SECRET_KEY.test(key || arg)) {
+      return arg.includes("=") ? `${key}=REDACTED` : arg
+    }
+
+    return arg
+  })
+}
+
+function buildRequestBaseUrl(request: FastifyRequest): string {
+  const host = request.headers.host?.trim()
+  if (!host) {
+    return "https://127.0.0.1:9898"
+  }
+  return `${request.protocol}://${host}`.replace(/\/+$/, "")
+}
+
+function getPreviewReservedPort(profile: z.infer<typeof ExecutionProfileSchema>): number | undefined {
+  return profile.kind === "docker" || profile.kind === "ssh" ? 17600 : undefined
+}
+
+function getPreviewCallbackPort(profile: z.infer<typeof ExecutionProfileSchema>): number | undefined {
+  return profile.kind === "ssh" ? 17601 : undefined
+}
+
+function buildExecutionProfilePreview(
+  input: z.infer<typeof ExecutionProfilePreviewSchema>,
+  options: { settings: SettingsService; requestBaseUrl: string },
+): ExecutionProfilePreviewResponse {
+  const workspacePath = input.workspacePath?.trim() || (process.platform === "win32" ? "C:/workspace" : "/workspace")
+  const execution =
+    input.profile.kind === "local"
+      ? {
+          kind: "local" as const,
+          path: input.profile.binaryPath,
+          label: input.profile.name,
+        }
+      : input.profile.kind === "wsl"
+        ? {
+            kind: "wsl" as const,
+            path: input.profile.binaryPath,
+            wslDistro: input.profile.distro,
+            label: input.profile.name,
+          }
+        : input.profile.kind === "docker"
+          ? {
+              kind: "docker" as const,
+              label: input.profile.name,
+              image: input.profile.image,
+              workspaceMountPath: input.profile.workspaceMountPath,
+              configMountPath: input.profile.configMountPath,
+              command: input.profile.command,
+              extraDockerArgs: input.profile.extraDockerArgs,
+            }
+          : input.profile.kind === "command"
+            ? {
+                kind: "command" as const,
+                label: input.profile.name,
+                executable: input.profile.executable,
+                args: input.profile.args,
+                cwdMode: input.profile.cwdMode,
+              }
+            : {
+                kind: "ssh" as const,
+                label: input.profile.name,
+                host: input.profile.host,
+                port: input.profile.port,
+                username: input.profile.username,
+                remotePath: input.profile.remotePath,
+                binaryPath: input.profile.binaryPath,
+                args: input.profile.args,
+              }
+
+  const userEnvironment = readConfiguredServerEnvironment(options.settings)
+  const previewInstanceId = "preview-instance"
+  const normalizedBaseUrl = options.requestBaseUrl.replace(/\/+$/, "")
+  const opencodeConfigContent = buildOpencodeConfigContent(
+    resolveExistingOpencodeConfigContent(userEnvironment),
+    getCodeNomadPluginUrl(),
+  )
+  const { username } = resolveOpencodeServerAuth({
+    userEnvironment,
+    processEnv: process.env,
+  })
+
+  const environment = {
+    ...redactPreviewEnvironment(userEnvironment),
+    OPENCODE_CONFIG_CONTENT: opencodeConfigContent,
+    CODENOMAD_INSTANCE_ID: previewInstanceId,
+    CODENOMAD_BASE_URL: normalizedBaseUrl,
+    [OPENCODE_SERVER_BASE_URL_ENV]: `${normalizedBaseUrl}/workspaces/${previewInstanceId}/worktrees/root/instance`,
+    [OPENCODE_SERVER_USERNAME_ENV]: username,
+    [OPENCODE_SERVER_PASSWORD_ENV]: "REDACTED",
+  }
+
+  const launch = buildLaunchPreview({
+    execution,
+    workspacePath,
+    environment,
+    logLevel: readConfiguredLogLevel(options.settings),
+    reservedPort: getPreviewReservedPort(input.profile),
+    callbackPort: getPreviewCallbackPort(input.profile),
+  })
+
+  const redactedArgs = redactPreviewArgs(launch.args)
+
+  return {
+    command: launch.command,
+    args: redactedArgs,
+    commandLine: formatCommandLine(launch.command, redactedArgs),
+    cwd: launch.cwd,
+    environment: launch.environment ?? {},
+  }
+}
+
+function testExecutionProfile(
+  input: z.infer<typeof ExecutionProfilePreviewSchema>,
+  options: { settings: SettingsService; requestBaseUrl: string },
+): ExecutionProfileTestResponse {
+  const preview = buildExecutionProfilePreview(input, options)
+  const validation =
+    input.profile.kind === "docker"
+      ? validateDockerImage(input.profile.image)
+      : input.profile.kind === "command"
+        ? validateBinaryPath(input.profile.executable)
+        : input.profile.kind === "ssh"
+          ? validateBinaryPath("ssh")
+          : validateBinaryPath(input.profile.binaryPath, input.profile.kind === "wsl" ? { wslDistro: input.profile.distro } : {})
+
+  return {
+    ...preview,
+    valid: validation.valid,
+    version: validation.version,
+    ...(validation.error ? { error: validation.error } : {}),
+  }
+}
+
 export function registerSettingsRoutes(app: FastifyInstance, deps: RouteDeps) {
   // Full-document access
   app.get("/api/storage/config", async () => sanitizeConfigDoc(deps.settings.getDoc("config")))
@@ -81,4 +359,32 @@ export function registerSettingsRoutes(app: FastifyInstance, deps: RouteDeps) {
       return { valid: false, error: error instanceof Error ? error.message : "Invalid request" }
     }
   })
+
+  app.post("/api/storage/execution-profiles/preview", async (request, reply) => {
+    try {
+      const body = ExecutionProfilePreviewSchema.parse(request.body ?? {})
+      return buildExecutionProfilePreview(body, {
+        settings: deps.settings,
+        requestBaseUrl: buildRequestBaseUrl(request),
+      })
+    } catch (error) {
+      deps.logger.warn({ err: error }, "Failed to preview execution profile")
+      reply.code(400)
+      return { error: error instanceof Error ? error.message : "Invalid request" }
+    }
+  })
+
+  app.post("/api/storage/execution-profiles/test", async (request, reply) => {
+    try {
+      const body = ExecutionProfilePreviewSchema.parse(request.body ?? {})
+      return testExecutionProfile(body, {
+        settings: deps.settings,
+        requestBaseUrl: buildRequestBaseUrl(request),
+      })
+    } catch (error) {
+      deps.logger.warn({ err: error }, "Failed to test execution profile")
+      reply.code(400)
+      return { error: error instanceof Error ? error.message : "Invalid request" }
+    }
+  })
 }
diff --git a/packages/server/src/server/routes/workspaces.ts b/packages/server/src/server/routes/workspaces.ts
index 517367f56..539aa0e2d 100644
--- a/packages/server/src/server/routes/workspaces.ts
+++ b/packages/server/src/server/routes/workspaces.ts
@@ -14,6 +14,7 @@ interface RouteDeps {
 const WorkspaceCreateSchema = z.object({
   path: z.string(),
   name: z.string().optional(),
+  executionProfileId: z.string().trim().optional(),
 })
 
 const WorkspaceCloneSchema = z.object({
@@ -67,7 +68,9 @@ export function registerWorkspaceRoutes(app: FastifyInstance, deps: RouteDeps) {
   app.post("/api/workspaces", async (request, reply) => {
     try {
       const body = WorkspaceCreateSchema.parse(request.body ?? {})
-      const workspace = await deps.workspaceManager.create(body.path, body.name)
+      const workspace = await deps.workspaceManager.create(body.path, body.name, {
+        executionProfileId: body.executionProfileId,
+      })
       reply.code(201)
       return workspace
     } catch (error) {
diff --git a/packages/server/src/settings/binaries.test.ts b/packages/server/src/settings/binaries.test.ts
new file mode 100644
index 000000000..ff0730ba3
--- /dev/null
+++ b/packages/server/src/settings/binaries.test.ts
@@ -0,0 +1,193 @@
+import assert from "node:assert/strict"
+import { describe, it } from "node:test"
+
+import type { ExecutionProfile } from "../api-types"
+import { BinaryResolver } from "./binaries"
+
+function createSettings(input?: {
+  server?: Record<string, unknown>
+  ui?: Record<string, unknown>
+}) {
+  return {
+    getOwner(kind: "config" | "state", owner: string) {
+      if (kind === "config" && owner === "server") {
+        return input?.server ?? {}
+      }
+      if (kind === "state" && owner === "ui") {
+        return input?.ui ?? {}
+      }
+      return {}
+    },
+  }
+}
+
+describe("BinaryResolver", () => {
+  it("falls back to the configured default binary when no launch profile is selected", () => {
+    const resolver = new BinaryResolver(
+      createSettings({
+        server: { opencodeBinary: "opencode-custom" },
+        ui: { opencodeBinaries: [{ path: "opencode-custom", label: "Custom OpenCode", version: "1.2.3" }] },
+      }) as any,
+    )
+
+    assert.deepEqual(resolver.resolveActive(), {
+      kind: "local",
+      path: "opencode-custom",
+      label: "Custom OpenCode",
+      version: "1.2.3",
+    })
+  })
+
+  it("resolves an explicit local launch profile", () => {
+    const profile: ExecutionProfile = {
+      id: "local-default",
+      name: "Local Default",
+      kind: "local",
+      binaryPath: "C:/Tools/opencode.exe",
+    }
+
+    const resolver = new BinaryResolver(
+      createSettings({
+        server: { executionProfiles: [profile] },
+      }) as any,
+    )
+
+    assert.deepEqual(resolver.resolveActive(profile.id), {
+      kind: "local",
+      path: "C:/Tools/opencode.exe",
+      label: "Local Default",
+      executionProfileId: "local-default",
+      executionProfileName: "Local Default",
+      executionProfileKind: "local",
+    })
+  })
+
+  it("resolves a default WSL launch profile from server config", () => {
+    const profile: ExecutionProfile = {
+      id: "wsl-ubuntu",
+      name: "WSL Ubuntu",
+      kind: "wsl",
+      distro: "Ubuntu",
+      binaryPath: String.raw`\\wsl.localhost\Ubuntu\home\dev\.opencode\bin\opencode`,
+    }
+
+    const resolver = new BinaryResolver(
+      createSettings({
+        server: {
+          executionProfiles: [profile],
+          defaultExecutionProfileId: profile.id,
+          opencodeBinary: "opencode",
+        },
+      }) as any,
+    )
+
+    assert.deepEqual(resolver.resolveActive(), {
+      kind: "wsl",
+      path: String.raw`\\wsl.localhost\Ubuntu\home\dev\.opencode\bin\opencode`,
+      wslDistro: "Ubuntu",
+      label: "WSL Ubuntu",
+      executionProfileId: "wsl-ubuntu",
+      executionProfileName: "WSL Ubuntu",
+      executionProfileKind: "wsl",
+    })
+  })
+
+  it("resolves a docker execution profile", () => {
+    const profile: ExecutionProfile = {
+      id: "docker-sandbox",
+      name: "Docker Sandbox",
+      kind: "docker",
+      image: "ghcr.io/example/opencode:latest",
+      workspaceMountPath: "/workspace",
+      configMountPath: "/root/.config/opencode",
+      command: ["opencode"],
+      extraDockerArgs: ["--init"],
+    }
+
+    const resolver = new BinaryResolver(
+      createSettings({
+        server: { executionProfiles: [profile] },
+      }) as any,
+    )
+
+    assert.deepEqual(resolver.resolveActive(profile.id), {
+      kind: "docker",
+      label: "Docker Sandbox",
+      image: "ghcr.io/example/opencode:latest",
+      workspaceMountPath: "/workspace",
+      configMountPath: "/root/.config/opencode",
+      command: ["opencode"],
+      extraDockerArgs: ["--init"],
+      executionProfileId: "docker-sandbox",
+      executionProfileName: "Docker Sandbox",
+      executionProfileKind: "docker",
+    })
+  })
+
+  it("resolves a command execution profile", () => {
+    const profile: ExecutionProfile = {
+      id: "custom-wrapper",
+      name: "Custom Wrapper",
+      kind: "command",
+      executable: "node",
+      args: ["scripts/opencode-wrapper.mjs"],
+      cwdMode: "inherit",
+    }
+
+    const resolver = new BinaryResolver(
+      createSettings({
+        server: { executionProfiles: [profile] },
+      }) as any,
+    )
+
+    assert.deepEqual(resolver.resolveActive(profile.id), {
+      kind: "command",
+      label: "Custom Wrapper",
+      executable: "node",
+      args: ["scripts/opencode-wrapper.mjs"],
+      cwdMode: "inherit",
+      executionProfileId: "custom-wrapper",
+      executionProfileName: "Custom Wrapper",
+      executionProfileKind: "command",
+    })
+  })
+
+  it("resolves an SSH execution profile", () => {
+    const profile: ExecutionProfile = {
+      id: "ssh-linux",
+      name: "SSH Linux",
+      kind: "ssh",
+      host: "vm.example.com",
+      port: 2222,
+      username: "ubuntu",
+      remotePath: "/srv/project",
+      binaryPath: "opencode",
+      args: ["--experimental"],
+    }
+
+    const resolver = new BinaryResolver(
+      createSettings({
+        server: { executionProfiles: [profile] },
+      }) as any,
+    )
+
+    assert.deepEqual(resolver.resolveActive(profile.id), {
+      kind: "ssh",
+      label: "SSH Linux",
+      host: "vm.example.com",
+      port: 2222,
+      username: "ubuntu",
+      remotePath: "/srv/project",
+      binaryPath: "opencode",
+      args: ["--experimental"],
+      executionProfileId: "ssh-linux",
+      executionProfileName: "SSH Linux",
+      executionProfileKind: "ssh",
+    })
+  })
+
+  it("throws when an explicit execution profile id does not exist", () => {
+    const resolver = new BinaryResolver(createSettings() as any)
+    assert.throws(() => resolver.resolveActive("missing-profile"), /Execution profile not found/)
+  })
+})
diff --git a/packages/server/src/settings/binaries.ts b/packages/server/src/settings/binaries.ts
index e4b25960b..00592296e 100644
--- a/packages/server/src/settings/binaries.ts
+++ b/packages/server/src/settings/binaries.ts
@@ -1,4 +1,13 @@
 import type { SettingsService } from "./service"
+import type {
+  CommandExecutionProfile,
+  DockerExecutionProfile,
+  ExecutionProfile,
+  ExecutionProfileKind,
+  LocalExecutionProfile,
+  SshExecutionProfile,
+  WslExecutionProfile,
+} from "../api-types"
 
 export interface OpenCodeBinaryEntry {
   path: string
@@ -7,12 +16,48 @@ export interface OpenCodeBinaryEntry {
   label?: string
 }
 
-export interface ResolvedBinary {
-  path: string
+interface ResolvedExecutionBase {
   label: string
   version?: string
+  executionProfileId?: string
+  executionProfileName?: string
+  executionProfileKind?: ExecutionProfileKind
+}
+
+export interface ResolvedHostExecution extends ResolvedExecutionBase {
+  kind: "local" | "wsl"
+  path: string
+  wslDistro?: string
+}
+
+export interface ResolvedDockerExecution extends ResolvedExecutionBase {
+  kind: "docker"
+  image: string
+  workspaceMountPath: string
+  configMountPath: string
+  command?: string[]
+  extraDockerArgs?: string[]
+}
+
+export interface ResolvedCommandExecution extends ResolvedExecutionBase {
+  kind: "command"
+  executable: string
+  args?: string[]
+  cwdMode?: "workspace" | "inherit"
 }
 
+export interface ResolvedSshExecution extends ResolvedExecutionBase {
+  kind: "ssh"
+  host: string
+  port?: number
+  username?: string
+  remotePath: string
+  binaryPath: string
+  args?: string[]
+}
+
+export type ResolvedBinary = ResolvedHostExecution | ResolvedDockerExecution | ResolvedCommandExecution | ResolvedSshExecution
+
 function prettyLabel(p: string): string {
   const parts = p.split(/[\\/]/)
   const last = parts[parts.length - 1] || p
@@ -32,6 +77,23 @@ function readDefaultBinaryPath(settings: SettingsService): string | undefined {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined
 }
 
+function isExecutionProfile(value: unknown): value is ExecutionProfile {
+  return !!value && typeof value === "object" && typeof (value as any).id === "string" && typeof (value as any).kind === "string"
+}
+
+function readExecutionProfiles(settings: SettingsService): ExecutionProfile[] {
+  const server = settings.getOwner("config", "server")
+  const list = (server as any)?.executionProfiles
+  if (!Array.isArray(list)) return []
+  return list.filter(isExecutionProfile)
+}
+
+function readDefaultExecutionProfileId(settings: SettingsService): string | undefined {
+  const server = settings.getOwner("config", "server")
+  const value = (server as any)?.defaultExecutionProfileId
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined
+}
+
 export class BinaryResolver {
   constructor(private readonly settings: SettingsService) {}
 
@@ -39,6 +101,28 @@ export class BinaryResolver {
     return readUiBinaries(this.settings)
   }
 
+  listExecutionProfiles(): ExecutionProfile[] {
+    return readExecutionProfiles(this.settings)
+  }
+
+  resolveActive(executionProfileId?: string): ResolvedBinary {
+    const profiles = this.listExecutionProfiles()
+    const requestedId = executionProfileId?.trim() || readDefaultExecutionProfileId(this.settings)
+    if (!requestedId) {
+      return this.resolveDefault()
+    }
+
+    const profile = profiles.find((entry) => entry.id === requestedId)
+    if (!profile) {
+      if (executionProfileId?.trim()) {
+        throw new Error(`Execution profile not found: ${executionProfileId}`)
+      }
+      return this.resolveDefault()
+    }
+
+    return this.resolveProfile(profile)
+  }
+
   resolveDefault(): ResolvedBinary {
     const binaries = this.list()
     const configuredDefault = readDefaultBinaryPath(this.settings)
@@ -47,9 +131,89 @@ export class BinaryResolver {
 
     const entry = binaries.find((b) => b.path === path)
     return {
+      kind: "local",
       path,
       label: entry?.label ?? prettyLabel(path),
       version: entry?.version,
     }
   }
+
+  private resolveProfile(profile: ExecutionProfile): ResolvedBinary {
+    const shared = {
+      label: profile.name,
+      executionProfileId: profile.id,
+      executionProfileName: profile.name,
+      executionProfileKind: profile.kind,
+    }
+
+    if (profile.kind === "local") {
+      return this.resolveLocalProfile(profile, shared)
+    }
+
+    if (profile.kind === "wsl") {
+      return this.resolveWslProfile(profile, shared)
+    }
+
+    if (profile.kind === "docker") {
+      return this.resolveDockerProfile(profile, shared)
+    }
+
+    if (profile.kind === "command") {
+      return this.resolveCommandProfile(profile, shared)
+    }
+
+    return this.resolveSshProfile(profile, shared)
+  }
+
+  private resolveLocalProfile(profile: LocalExecutionProfile, shared: Omit<ResolvedHostExecution, "kind" | "path">): ResolvedHostExecution {
+    return {
+      ...shared,
+      kind: "local",
+      path: profile.binaryPath,
+    }
+  }
+
+  private resolveWslProfile(profile: WslExecutionProfile, shared: Omit<ResolvedHostExecution, "kind" | "path">): ResolvedHostExecution {
+    return {
+      ...shared,
+      kind: "wsl",
+      path: profile.binaryPath,
+      wslDistro: profile.distro,
+    }
+  }
+
+  private resolveDockerProfile(profile: DockerExecutionProfile, shared: Omit<ResolvedDockerExecution, "kind" | "image" | "workspaceMountPath" | "configMountPath">): ResolvedDockerExecution {
+    return {
+      ...shared,
+      kind: "docker",
+      image: profile.image,
+      workspaceMountPath: profile.workspaceMountPath,
+      configMountPath: profile.configMountPath,
+      command: profile.command,
+      extraDockerArgs: profile.extraDockerArgs,
+    }
+  }
+
+  private resolveCommandProfile(profile: CommandExecutionProfile, shared: Omit<ResolvedCommandExecution, "kind" | "executable">): ResolvedCommandExecution {
+    return {
+      ...shared,
+      kind: "command",
+      executable: profile.executable,
+      args: profile.args,
+      cwdMode: profile.cwdMode,
+    }
+  }
+
+  private resolveSshProfile(profile: SshExecutionProfile, shared: Omit<ResolvedSshExecution, "kind" | "host" | "remotePath" | "binaryPath">): ResolvedSshExecution {
+    return {
+      ...shared,
+      kind: "ssh",
+      host: profile.host,
+      port: profile.port,
+      username: profile.username,
+      remotePath: profile.remotePath,
+      binaryPath: profile.binaryPath,
+      args: profile.args,
+    }
+  }
 }
diff --git a/packages/server/src/settings/service.ts b/packages/server/src/settings/service.ts
index f4f0409c2..b5a40bc49 100644
--- a/packages/server/src/settings/service.ts
+++ b/packages/server/src/settings/service.ts
@@ -14,6 +14,65 @@ const CanonicalLogLevelSchema = z.preprocess(
   z.enum(["DEBUG", "INFO", "WARN", "ERROR"]),
 )
 
+const ExecutionProfileIdSchema = z.string().trim().min(1)
+const ExecutionProfileNameSchema = z.string().trim().min(1)
+const ExecutionProfileStringListSchema = z.array(z.string().trim().min(1)).max(64)
+
+const LocalExecutionProfileSchema = z.object({
+  id: ExecutionProfileIdSchema,
+  name: ExecutionProfileNameSchema,
+  kind: z.literal("local"),
+  binaryPath: z.string().trim().min(1),
+})
+
+const WslExecutionProfileSchema = z.object({
+  id: ExecutionProfileIdSchema,
+  name: ExecutionProfileNameSchema,
+  kind: z.literal("wsl"),
+  distro: z.string().trim().min(1),
+  binaryPath: z.string().trim().min(1),
+})
+
+const DockerExecutionProfileSchema = z.object({
+  id: ExecutionProfileIdSchema,
+  name: ExecutionProfileNameSchema,
+  kind: z.literal("docker"),
+  image: z.string().trim().min(1),
+  workspaceMountPath: z.string().trim().min(1),
+  configMountPath: z.string().trim().min(1),
+  command: ExecutionProfileStringListSchema.optional(),
+  extraDockerArgs: ExecutionProfileStringListSchema.optional(),
+})
+
+const CommandExecutionProfileSchema = z.object({
+  id: ExecutionProfileIdSchema,
+  name: ExecutionProfileNameSchema,
+  kind: z.literal("command"),
+  executable: z.string().trim().min(1),
+  args: ExecutionProfileStringListSchema.optional(),
+  cwdMode: z.enum(["workspace", "inherit"]).optional(),
+})
+
+const SshExecutionProfileSchema = z.object({
+  id: ExecutionProfileIdSchema,
+  name: ExecutionProfileNameSchema,
+  kind: z.literal("ssh"),
+  host: z.string().trim().min(1),
+  port: z.number().int().positive().max(65535).optional(),
+  username: z.string().trim().optional(),
+  remotePath: z.string().trim().min(1),
+  binaryPath: z.string().trim().min(1),
+  args: ExecutionProfileStringListSchema.optional(),
+})
+
+const ExecutionProfileSchema = z.discriminatedUnion("kind", [
+  LocalExecutionProfileSchema,
+  WslExecutionProfileSchema,
+  DockerExecutionProfileSchema,
+  CommandExecutionProfileSchema,
+  SshExecutionProfileSchema,
+])
+
 function isPlainObject(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value)
 }
@@ -39,6 +98,25 @@ function normalizeServerConfigOwner(value: SettingsDoc): SettingsDoc {
   } else if (next.logLevel !== undefined) {
     next.logLevel = "DEBUG"
   }
+
+   if (Array.isArray(next.executionProfiles)) {
+     next.executionProfiles = next.executionProfiles.flatMap((profile) => {
+       const parsed = ExecutionProfileSchema.safeParse(profile)
+       return parsed.success ? [parsed.data] : []
+     })
+   } else if (next.executionProfiles !== undefined) {
+     next.executionProfiles = []
+   }
+
+   const parsedDefaultExecutionProfileId = ExecutionProfileIdSchema.safeParse(next.defaultExecutionProfileId)
+   if (parsedDefaultExecutionProfileId.success) {
+     const profiles = Array.isArray(next.executionProfiles) ? next.executionProfiles : []
+     const exists = profiles.some((profile) => isPlainObject(profile) && profile.id === parsedDefaultExecutionProfileId.data)
+     next.defaultExecutionProfileId = exists ? parsedDefaultExecutionProfileId.data : undefined
+   } else if (next.defaultExecutionProfileId !== undefined) {
+     next.defaultExecutionProfileId = undefined
+   }
+
   return next
 }
 
diff --git a/packages/server/src/workspaces/__tests__/spawn.test.ts b/packages/server/src/workspaces/__tests__/spawn.test.ts
index 7b829ac75..785dcc599 100644
--- a/packages/server/src/workspaces/__tests__/spawn.test.ts
+++ b/packages/server/src/workspaces/__tests__/spawn.test.ts
@@ -79,6 +79,27 @@ describe("buildWindowsSpawnSpec", () => {
     assert.equal(spec.env?.WSLENV, "OPENCODE_CONFIG_CONTENT:CODENOMAD_INSTANCE_ID:OPENCODE_SERVER_BASE_URL:OPENCODE_SERVER_PASSWORD")
   })
 
+  it("wraps plain Linux binary paths when a WSL distro is provided", () => {
+    const spec = buildWindowsSpawnSpec("/home/dev/.opencode/bin/opencode", ["serve"], {
+      cwd: String.raw`C:\Users\dev\workspace`,
+      wslDistro: "Ubuntu",
+    })
+
+    assert.equal(spec.command, "wsl.exe")
+    assert.deepEqual(spec.args, [
+      "--distribution",
+      "Ubuntu",
+      "--exec",
+      "sh",
+      "-lc",
+      'cd "$(wslpath -au "$1")" && shift && exec "$@"',
+      "codenomad-wsl-launch",
+      String.raw`C:\Users\dev\workspace`,
+      "/home/dev/.opencode/bin/opencode",
+      "serve",
+    ])
+  })
+
   it("preserves non-path OPENCODE_CONFIG_CONTENT WSLENV entries", () => {
     const spec = buildWindowsSpawnSpec(
       String.raw`\\wsl.localhost\Ubuntu\home\dev\.opencode\bin\opencode`,
diff --git a/packages/server/src/workspaces/execution-launch.test.ts b/packages/server/src/workspaces/execution-launch.test.ts
new file mode 100644
index 000000000..8746e3758
--- /dev/null
+++ b/packages/server/src/workspaces/execution-launch.test.ts
@@ -0,0 +1,186 @@
+import assert from "node:assert/strict"
+import { describe, it } from "node:test"
+
+import type { ResolvedBinary } from "../settings/binaries"
+import { buildLaunchCommand, buildLaunchPreview, formatCommandLine } from "./execution-launch"
+
+describe("buildLaunchCommand", () => {
+  it("builds a command execution profile launch", () => {
+    const execution: ResolvedBinary = {
+      kind: "command",
+      label: "Wrapper",
+      executable: "node",
+      args: ["scripts/opencode-wrapper.mjs"],
+      cwdMode: "inherit",
+    }
+
+    const result = buildLaunchCommand({
+      execution,
+      workspacePath: "D:/CodeNomad",
+      environment: { CODENOMAD_INSTANCE_ID: "abc123" },
+      logLevel: "DEBUG",
+    })
+
+    assert.equal(result.command, "node")
+    assert.deepEqual(result.args, ["scripts/opencode-wrapper.mjs", "serve", "--port", "0", "--print-logs", "--log-level", "DEBUG"])
+    assert.equal(result.cwd, undefined)
+    assert.deepEqual(result.environment, { CODENOMAD_INSTANCE_ID: "abc123" })
+  })
+
+  it("builds a docker execution profile launch with rewritten paths and URLs", () => {
+    const execution: ResolvedBinary = {
+      kind: "docker",
+      label: "Docker Sandbox",
+      image: "ghcr.io/example/opencode:latest",
+      workspaceMountPath: "/workspace",
+      configMountPath: "/root/.config/opencode",
+      command: ["opencode"],
+      extraDockerArgs: ["--init"],
+    }
+
+    const result = buildLaunchCommand({
+      execution,
+      workspacePath: "D:/CodeNomad",
+      environment: {
+        OPENCODE_CONFIG_CONTENT: JSON.stringify({
+          plugin: [
+            "@codenomad/codenomad-opencode-plugin@file:C:/Users/Admin/.config/CodeNomad/codenomad-opencode-plugin.tgz",
+          ],
+        }),
+        NODE_EXTRA_CA_CERTS: "C:/Users/Admin/.config/codenomad/certs.pem",
+        CODENOMAD_BASE_URL: "https://127.0.0.1:9898",
+        OPENCODE_SERVER_BASE_URL: "https://127.0.0.1:9898/workspaces/abc/worktrees/root/instance",
+      },
+      logLevel: "INFO",
+      reservedPort: 17600,
+    })
+
+    assert.equal(result.command, "docker")
+    assert.ok(result.args.includes("ghcr.io/example/opencode:latest"))
+    assert.ok(result.args.includes("D:/CodeNomad:/workspace"))
+    assert.ok(result.args.includes("C:/Users/Admin/.config/CodeNomad/codenomad-opencode-plugin.tgz:/root/.config/opencode/codenomad-opencode-plugin.tgz:ro"))
+    assert.ok(result.args.includes("C:/Users/Admin/.config/codenomad/certs.pem:/tmp/codenomad-node-extra-ca.pem:ro"))
+    assert.ok(result.args.includes("127.0.0.1:17600:17600"))
+    assert.ok(result.args.includes("CODENOMAD_BASE_URL"))
+    assert.ok(result.args.includes("OPENCODE_CONFIG_CONTENT"))
+    assert.ok(result.args.includes("NODE_EXTRA_CA_CERTS"))
+    assert.equal(result.environment?.CODENOMAD_BASE_URL, "https://host.docker.internal:9898")
+    assert.match(result.environment?.OPENCODE_CONFIG_CONTENT ?? "", /\/root\/\.config\/opencode\/codenomad-opencode-plugin\.tgz/)
+    assert.equal(result.environment?.NODE_EXTRA_CA_CERTS, "/tmp/codenomad-node-extra-ca.pem")
+    assert.deepEqual(result.args.slice(-8), ["serve", "--port", "17600", "--print-logs", "--log-level", "INFO", "--hostname", "0.0.0.0"])
+  })
+
+  it("requires a reserved local port for Docker execution profiles", () => {
+    const execution: ResolvedBinary = {
+      kind: "docker",
+      label: "Docker Sandbox",
+      image: "ghcr.io/example/opencode:latest",
+      workspaceMountPath: "/workspace",
+      configMountPath: "/root/.config/opencode",
+    }
+
+    assert.throws(
+      () => buildLaunchCommand({
+        execution,
+        workspacePath: "D:/CodeNomad",
+        environment: { OPENCODE_CONFIG_CONTENT: JSON.stringify({ plugin: [] }) },
+        logLevel: "INFO",
+      }),
+      /Reserved local port is required/,
+    )
+  })
+
+  it("builds an SSH execution profile launch with forward and reverse tunnels", () => {
+    const execution: ResolvedBinary = {
+      kind: "ssh",
+      label: "SSH Linux",
+      host: "vm.example.com",
+      port: 2222,
+      username: "ubuntu",
+      remotePath: "/srv/project",
+      binaryPath: "opencode",
+    }
+
+    const result = buildLaunchCommand({
+      execution,
+      workspacePath: "/unused/local/path",
+      environment: {
+        CODENOMAD_BASE_URL: "http://127.0.0.1:9898",
+        OPENCODE_SERVER_BASE_URL: "http://127.0.0.1:9898/workspaces/abc/worktrees/root/instance",
+      },
+      logLevel: "DEBUG",
+      reservedPort: 17600,
+      callbackPort: 17601,
+    })
+
+    assert.equal(result.command, "ssh")
+    assert.ok(result.args.includes("127.0.0.1:17600:127.0.0.1:17600"))
+    assert.ok(result.args.includes("127.0.0.1:17601:127.0.0.1:9898"))
+    assert.ok(result.args.includes("ubuntu@vm.example.com"))
+    assert.deepEqual(result.args.slice(-2), ["sh", "-s"])
+    assert.ok(result.stdin?.includes("exec env"))
+    assert.ok(result.stdin?.includes("opencode"))
+    assert.ok(result.stdin?.includes("--port"))
+    assert.ok(result.stdin?.includes("17600"))
+    assert.ok(result.stdin?.includes("OPENCODE_SERVER_BASE_URL='http://127.0.0.1:17601/workspaces/abc/worktrees/root/instance'"))
+  })
+
+  it("rejects unsafe SSH environment variable names", () => {
+    const execution: ResolvedBinary = {
+      kind: "ssh",
+      label: "SSH Linux",
+      host: "vm.example.com",
+      remotePath: "/srv/project",
+      binaryPath: "opencode",
+    }
+
+    assert.throws(
+      () => buildLaunchCommand({
+        execution,
+        workspacePath: "/unused/local/path",
+        environment: { "BAD;touch /tmp/pwned": "value" },
+        logLevel: "DEBUG",
+        reservedPort: 17600,
+        callbackPort: 17601,
+      }),
+      /Invalid environment variable name/,
+    )
+  })
+
+  it("formats preview command lines with quoting", () => {
+    assert.equal(formatCommandLine("docker", ["run", "C:/Program Files/OpenCode/opencode.exe", "--flag"]), 'docker run "C:/Program Files/OpenCode/opencode.exe" --flag')
+  })
+
+  if (process.platform === "win32") {
+    it("builds a WSL preview using the actual spawn command", () => {
+      const execution: ResolvedBinary = {
+        kind: "wsl",
+        label: "Ubuntu",
+        path: String.raw`\\wsl.localhost\Ubuntu\home\dev\.opencode\bin\opencode`,
+      }
+
+      const result = buildLaunchPreview({
+        execution,
+        workspacePath: String.raw`D:\CodeNomad`,
+        environment: {
+          OPENCODE_CONFIG_CONTENT: JSON.stringify({ plugin: ["npm:user-plugin"] }),
+          CODENOMAD_INSTANCE_ID: "preview-instance",
+          OPENCODE_SERVER_BASE_URL: "https://127.0.0.1:9898/workspaces/preview-instance/worktrees/root/instance",
+          OPENCODE_SERVER_PASSWORD: "REDACTED",
+        },
+        logLevel: "DEBUG",
+      })
+
+      assert.equal(result.command, "wsl.exe")
+      assert.deepEqual(result.args.slice(0, 6), [
+        "--distribution",
+        "Ubuntu",
+        "--exec",
+        "sh",
+        "-lc",
+        'printf \'%s%s\\n\' \'__CODENOMAD_WSL_PID__:\' "$$" && cd "$(wslpath -au "$1")" && shift && exec "$@"',
+      ])
+      assert.equal(result.environment?.WSLENV, "OPENCODE_CONFIG_CONTENT:CODENOMAD_INSTANCE_ID:OPENCODE_SERVER_BASE_URL:OPENCODE_SERVER_PASSWORD")
+    })
+  }
+})
diff --git a/packages/server/src/workspaces/execution-launch.ts b/packages/server/src/workspaces/execution-launch.ts
new file mode 100644
index 000000000..2889a508d
--- /dev/null
+++ b/packages/server/src/workspaces/execution-launch.ts
@@ -0,0 +1,320 @@
+import { URL } from "url"
+import type { ResolvedBinary } from "../settings/binaries"
+import {
+  findPackagedCodeNomadPluginReference,
+  rewritePackagedCodeNomadPluginReference,
+} from "../opencode-plugin.js"
+import { buildSpawnSpec, WSL_PID_MARKER } from "./spawn"
+
+const DOCKER_HOST_ALIAS = "host.docker.internal"
+const DOCKER_CA_CERT_PATH = "/tmp/codenomad-node-extra-ca.pem"
+const DOCKER_PLUGIN_TARBALL_NAME = "codenomad-opencode-plugin.tgz"
+
+export interface LaunchCommandSpec {
+  command: string
+  args: string[]
+  cwd?: string
+  environment?: Record<string, string>
+  wslDistro?: string
+  stdin?: string
+}
+
+interface BuildLaunchCommandParams {
+  execution: ResolvedBinary
+  workspacePath: string
+  environment: Record<string, string>
+  logLevel: string
+  reservedPort?: number
+  callbackPort?: number
+}
+
+export function buildLaunchCommand(params: BuildLaunchCommandParams): LaunchCommandSpec {
+  const openCodePort = (params.execution.kind === "docker" || params.execution.kind === "ssh") && params.reservedPort ? String(params.reservedPort) : "0"
+  const openCodeArgs = ["serve", "--port", openCodePort, "--print-logs", "--log-level", params.logLevel]
+  if (params.execution.kind === "docker") {
+    openCodeArgs.push("--hostname", "0.0.0.0")
+  }
+
+  if (params.execution.kind === "docker") {
+    if (!params.reservedPort) {
+      throw new Error("Reserved local port is required for Docker execution profiles")
+    }
+    return buildDockerLaunchCommand(params.execution, params.workspacePath, params.environment, openCodeArgs, params.reservedPort)
+  }
+
+  if (params.execution.kind === "command") {
+    return {
+      command: params.execution.executable,
+      args: [...(params.execution.args ?? []), ...openCodeArgs],
+      cwd: params.execution.cwdMode === "inherit" ? undefined : params.workspacePath,
+      environment: params.environment,
+    }
+  }
+
+  if (params.execution.kind === "ssh") {
+    if (!params.reservedPort || !params.callbackPort) {
+      throw new Error("Reserved local and callback ports are required for SSH execution profiles")
+    }
+    return buildSshLaunchCommand(params.execution, params.reservedPort, params.callbackPort, params.environment, openCodeArgs)
+  }
+
+  return {
+    command: params.execution.path,
+    args: openCodeArgs,
+    cwd: params.workspacePath,
+    environment: params.environment,
+    wslDistro: params.execution.kind === "wsl" ? params.execution.wslDistro : undefined,
+  }
+}
+
+function buildSshLaunchCommand(
+  execution: Extract<ResolvedBinary, { kind: "ssh" }>,
+  forwardedPort: number,
+  callbackPort: number,
+  environment: Record<string, string>,
+  openCodeArgs: string[],
+): LaunchCommandSpec {
+  const host = execution.host.trim()
+  if (!host || host.startsWith("-") || /\s/.test(host)) {
+    throw new Error("SSH host must not be empty, start with '-', or contain whitespace")
+  }
+
+  const username = execution.username?.trim()
+  if (username && (username.startsWith("-") || /[@\s]/.test(username))) {
+    throw new Error("SSH username must not start with '-' or contain '@' or whitespace")
+  }
+
+  const target = username ? `${username}@${host}` : host
+  const remoteEnvironment = rewriteSshCallbackEnvironment(environment, callbackPort)
+  const remoteScript = buildSshRemoteScript(execution, remoteEnvironment, openCodeArgs)
+
+  return {
+    command: "ssh",
+    args: [
+      "-p",
+      String(execution.port ?? 22),
+      "-o",
+      "BatchMode=yes",
+      "-o",
+      "ExitOnForwardFailure=yes",
+      "-L",
+      `127.0.0.1:${forwardedPort}:127.0.0.1:${forwardedPort}`,
+      "-R",
+      `127.0.0.1:${callbackPort}:127.0.0.1:${getUrlPort(environment.CODENOMAD_BASE_URL) ?? 9898}`,
+      target,
+      "sh",
+      "-s",
+    ],
+    environment: {},
+    stdin: remoteScript,
+  }
+}
+
+function buildSshRemoteScript(
+  execution: Extract<ResolvedBinary, { kind: "ssh" }>,
+  environment: Record<string, string>,
+  openCodeArgs: string[],
+): string {
+  const assignments = Object.entries(environment).map(([key, value]) => {
+    if (!isEnvironmentVariableName(key)) {
+      throw new Error(`Invalid environment variable name for SSH execution profile: ${key}`)
+    }
+    return `${key}=${shellQuote(value)}`
+  })
+
+  const command = [
+    "exec",
+    "env",
+    ...assignments,
+    shellQuote(execution.binaryPath),
+    ...(execution.args ?? []).map(shellQuote),
+    ...openCodeArgs.map(shellQuote),
+  ].join(" ")
+
+  return ["set -eu", `cd ${shellQuote(execution.remotePath)}`, command, ""].join("\n")
+}
+
+export function buildLaunchPreview(params: BuildLaunchCommandParams): LaunchCommandSpec {
+  const launch = buildLaunchCommand(params)
+  const explicitEnvironment = launch.environment ?? {}
+  const mergedEnvironment = { ...process.env, ...explicitEnvironment }
+  const spawnSpec = buildSpawnSpec(launch.command, launch.args, {
+    cwd: launch.cwd,
+    env: mergedEnvironment,
+    propagateEnvKeys: Object.keys(explicitEnvironment),
+    wslPidMarker: WSL_PID_MARKER,
+    wslDistro: launch.wslDistro,
+  })
+
+  return {
+    command: spawnSpec.command,
+    args: spawnSpec.args,
+    cwd: spawnSpec.cwd,
+    environment: collectPreviewEnvironment(explicitEnvironment, mergedEnvironment, spawnSpec.env),
+  }
+}
+
+export function formatCommandLine(command: string, args: string[]): string {
+  return [command, ...args].map(formatCommandToken).join(" ")
+}
+
+function buildDockerLaunchCommand(
+  execution: Extract<ResolvedBinary, { kind: "docker" }>,
+  workspacePath: string,
+  environment: Record<string, string>,
+  openCodeArgs: string[],
+  forwardedPort: number,
+): LaunchCommandSpec {
+  const configContent = environment.OPENCODE_CONFIG_CONTENT?.trim()
+  if (!configContent) {
+    throw new Error("OPENCODE_CONFIG_CONTENT is required for Docker execution profiles")
+  }
+
+  const containerEnvironment: Record<string, string> = { ...environment }
+  const packagedPlugin = findPackagedCodeNomadPluginReference(configContent)
+
+  if (containerEnvironment.CODENOMAD_BASE_URL) {
+    containerEnvironment.CODENOMAD_BASE_URL = rewriteDockerBaseUrl(containerEnvironment.CODENOMAD_BASE_URL)
+  }
+  if (containerEnvironment.OPENCODE_SERVER_BASE_URL) {
+    containerEnvironment.OPENCODE_SERVER_BASE_URL = rewriteDockerBaseUrl(containerEnvironment.OPENCODE_SERVER_BASE_URL)
+  }
+
+  const nodeExtraCaCerts = containerEnvironment.NODE_EXTRA_CA_CERTS?.trim()
+  const dockerArgs = [
+    "run",
+    "--rm",
+    "-i",
+    "--workdir",
+    execution.workspaceMountPath,
+    "--add-host",
+    `${DOCKER_HOST_ALIAS}:host-gateway`,
+    "-p",
+    `127.0.0.1:${forwardedPort}:${forwardedPort}`,
+    "-v",
+    `${workspacePath}:${execution.workspaceMountPath}`,
+  ]
+
+  if (packagedPlugin) {
+    const containerPluginPath = joinPosixPath(execution.configMountPath, DOCKER_PLUGIN_TARBALL_NAME)
+    containerEnvironment.OPENCODE_CONFIG_CONTENT = rewritePackagedCodeNomadPluginReference(configContent, containerPluginPath)
+    dockerArgs.push("-v", `${packagedPlugin.filePath.replace(/\\/g, "/")}:${containerPluginPath}:ro`)
+  }
+
+  if (nodeExtraCaCerts) {
+    dockerArgs.push("-v", `${nodeExtraCaCerts}:${DOCKER_CA_CERT_PATH}:ro`)
+    containerEnvironment.NODE_EXTRA_CA_CERTS = DOCKER_CA_CERT_PATH
+  }
+
+  for (const [key, value] of Object.entries(containerEnvironment)) {
+    dockerArgs.push("-e", key)
+  }
+
+  if (execution.extraDockerArgs?.length) {
+    dockerArgs.push(...execution.extraDockerArgs)
+  }
+
+  dockerArgs.push(execution.image)
+  dockerArgs.push(...(execution.command?.length ? execution.command : ["opencode"]))
+  dockerArgs.push(...openCodeArgs)
+
+  return {
+    command: "docker",
+    args: dockerArgs,
+    environment: containerEnvironment,
+  }
+}
+
+function collectPreviewEnvironment(
+  explicitEnvironment: Record<string, string>,
+  mergedEnvironment: NodeJS.ProcessEnv,
+  spawnEnvironment: NodeJS.ProcessEnv | undefined,
+): Record<string, string> {
+  const previewKeys = new Set(Object.keys(explicitEnvironment))
+
+  if (spawnEnvironment) {
+    for (const [key, value] of Object.entries(spawnEnvironment)) {
+      if (typeof value !== "string") {
+        continue
+      }
+      if (value !== mergedEnvironment[key]) {
+        previewKeys.add(key)
+      }
+    }
+  }
+
+  const previewEnvironment: Record<string, string> = {}
+  for (const key of previewKeys) {
+    const value = spawnEnvironment?.[key] ?? mergedEnvironment[key]
+    if (typeof value === "string") {
+      previewEnvironment[key] = value
+    }
+  }
+
+  return previewEnvironment
+}
+
+function formatCommandToken(token: string): string {
+  if (!token) {
+    return '""'
+  }
+
+  return /[\s"'`$&|<>()[\]{};\\]/.test(token) ? JSON.stringify(token) : token
+}
+
+function shellQuote(value: string): string {
+  if (!value) return "''"
+  return `'${value.replace(/'/g, `'"'"'`)}'`
+}
+
+function isEnvironmentVariableName(value: string): boolean {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(value)
+}
+
+function rewriteSshCallbackEnvironment(environment: Record<string, string>, callbackPort: number): Record<string, string> {
+  const rewritten = { ...environment }
+  for (const key of ["CODENOMAD_BASE_URL", "OPENCODE_SERVER_BASE_URL"]) {
+    const value = rewritten[key]
+    if (!value) continue
+    rewritten[key] = rewriteUrlHostPort(value, "127.0.0.1", callbackPort)
+  }
+  return rewritten
+}
+
+function rewriteUrlHostPort(value: string, host: string, port: number): string {
+  try {
+    const url = new URL(value)
+    url.hostname = host
+    url.port = String(port)
+    return url.toString().replace(/\/$/, "")
+  } catch {
+    return value
+  }
+}
+
+function getUrlPort(value?: string): number | undefined {
+  if (!value) return undefined
+  try {
+    const url = new URL(value)
+    const parsed = Number(url.port || (url.protocol === "https:" ? 443 : 80))
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined
+  } catch {
+    return undefined
+  }
+}
+
+function rewriteDockerBaseUrl(input: string): string {
+  try {
+    const url = new URL(input)
+    if (url.hostname === "127.0.0.1" || url.hostname === "localhost") {
+      url.hostname = DOCKER_HOST_ALIAS
+    }
+    return url.toString().replace(/\/$/, "")
+  } catch {
+    return input
+  }
+}
+
+function joinPosixPath(base: string, name: string): string {
+  return `${base.replace(/\/+$/, "")}/${name}`
+}
diff --git a/packages/server/src/workspaces/manager.ts b/packages/server/src/workspaces/manager.ts
index cd1933b2f..4424d617a 100644
--- a/packages/server/src/workspaces/manager.ts
+++ b/packages/server/src/workspaces/manager.ts
@@ -1,9 +1,9 @@
 import path from "path"
 import { spawnSync } from "child_process"
-import { connect } from "net"
+import { connect, createServer } from "net"
 import { EventBus } from "../events/bus"
 import type { SettingsService } from "../settings/service"
-import type { BinaryResolver } from "../settings/binaries"
+import type { BinaryResolver, ResolvedBinary } from "../settings/binaries"
 import { FileSystemBrowser } from "../filesystem/browser"
 import { searchWorkspaceFiles, WorkspaceFileSearchOptions } from "../filesystem/search"
 import { clearWorkspaceSearchCache } from "../filesystem/search-cache"
@@ -12,9 +12,12 @@ import { WorkspaceRuntime, ProcessExitInfo } from "./runtime"
 import { Logger } from "../logger"
 import {
   buildOpencodeConfigContent,
+  findPackagedCodeNomadPluginReference,
   getCodeNomadPluginUrl,
+  rewritePackagedCodeNomadPluginReference,
   resolveExistingOpencodeConfigContent,
 } from "../opencode-plugin.js"
+import { buildLaunchCommand } from "./execution-launch"
 import {
   OPENCODE_SERVER_BASE_URL_ENV,
   buildOpencodeBasicAuthHeader,
@@ -38,6 +41,16 @@ interface WorkspaceManagerOptions {
 
 interface WorkspaceRecord extends WorkspaceDescriptor {}
 
+interface SshPackagedPluginArtifact {
+  remotePath: string
+  configContent: string
+}
+
+function shellQuote(value: string): string {
+  if (!value) return "''"
+  return `'${value.replace(/'/g, `'"'"'`)}'`
+}
+
 export class WorkspaceManager {
   private readonly workspaces = new Map<string, WorkspaceRecord>()
   private readonly runtime: WorkspaceRuntime
@@ -95,15 +108,17 @@ export class WorkspaceManager {
     browser.writeFile(relativePath, contents)
   }
 
-  async create(folder: string, name?: string): Promise<WorkspaceDescriptor> {
+  async create(folder: string, name?: string, options?: { executionProfileId?: string }): Promise<WorkspaceDescriptor> {
  
     const id = `${Date.now().toString(36)}`
-    const binary = this.options.binaryResolver.resolveDefault()
-    const resolvedBinaryPath = this.resolveBinaryPath(binary.path)
+    const execution = this.options.binaryResolver.resolveActive(options?.executionProfileId)
+    const resolvedBinaryPath = this.resolveBinaryPath(
+      execution.kind === "command" ? execution.executable : execution.kind === "docker" ? "docker" : execution.kind === "ssh" ? "ssh" : execution.path,
+    )
     const workspacePath = path.isAbsolute(folder) ? folder : path.resolve(this.options.rootDir, folder)
     clearWorkspaceSearchCache(workspacePath)
 
-    this.options.logger.info({ workspaceId: id, folder: workspacePath, binary: resolvedBinaryPath }, "Creating workspace")
+    this.options.logger.info({ workspaceId: id, folder: workspacePath, binary: resolvedBinaryPath, executionKind: execution.kind }, "Creating workspace")
 
     const proxyPath = `/workspaces/${id}/worktrees/root/instance`
 
@@ -115,8 +130,11 @@ export class WorkspaceManager {
       status: "starting",
       proxyPath,
       binaryId: resolvedBinaryPath,
-      binaryLabel: binary.label,
-      binaryVersion: binary.version,
+      binaryLabel: execution.label,
+      binaryVersion: execution.version,
+      executionProfileId: execution.executionProfileId,
+      executionProfileName: execution.executionProfileName,
+      executionProfileKind: execution.executionProfileKind,
       createdAt: new Date().toISOString(),
       updatedAt: new Date().toISOString(),
     }
@@ -157,17 +175,45 @@ export class WorkspaceManager {
       [OPENCODE_SERVER_PASSWORD_ENV]: opencodePassword,
     }
 
+    const sshPackagedPlugin =
+      execution.kind === "ssh" ? await this.syncSshPackagedPlugin(execution, id, environment.OPENCODE_CONFIG_CONTENT) : undefined
+    if (sshPackagedPlugin) {
+      environment.OPENCODE_CONFIG_CONTENT = sshPackagedPlugin.configContent
+    }
+
     const logLevel = (serverConfig as any)?.logLevel
+    const reservedPort = execution.kind === "docker" || execution.kind === "ssh" ? await this.getAvailablePort() : undefined
+    const callbackPort = execution.kind === "ssh" ? await this.getAvailablePort() : undefined
+    const launchCommand = buildLaunchCommand({
+      execution,
+      workspacePath,
+      environment,
+      logLevel: typeof logLevel === "string" ? logLevel.toUpperCase() : "DEBUG",
+      reservedPort,
+      callbackPort,
+    })
+
+    let launchedPid: number | undefined
 
     try {
       const { pid, port, exitPromise, getLastOutput } = await this.runtime.launch({
         workspaceId: id,
         folder: workspacePath,
-        binaryPath: resolvedBinaryPath,
-        environment,
+        binaryPath: launchCommand.command,
+        commandArgs: launchCommand.args,
+        spawnCwd: launchCommand.cwd,
+        environment: launchCommand.environment,
+        wslDistro: launchCommand.wslDistro,
+        stdin: launchCommand.stdin,
         logLevel,
-        onExit: (info) => this.handleProcessExit(info.workspaceId, info),
+        onExit: (info) => {
+          if (execution.kind === "ssh" && sshPackagedPlugin) {
+            this.cleanupSshPackagedPlugin(execution, sshPackagedPlugin.remotePath)
+          }
+          this.handleProcessExit(info.workspaceId, info)
+        },
       })
+      launchedPid = pid
 
       const runtimeVersion = await this.waitForWorkspaceReadiness({ workspaceId: id, port, exitPromise, getLastOutput })
       if (runtimeVersion) {
@@ -187,6 +233,14 @@ export class WorkspaceManager {
       descriptor.updatedAt = new Date().toISOString()
       this.options.eventBus.publish({ type: "workspace.error", workspace: descriptor })
       this.options.logger.error({ workspaceId: id, err: error }, "Workspace failed to start")
+      if (launchedPid !== undefined) {
+        await this.runtime.stop(id).catch((stopError) => {
+          this.options.logger.warn({ workspaceId: id, err: stopError }, "Failed to stop workspace after startup failure")
+        })
+      }
+      if (execution.kind === "ssh" && sshPackagedPlugin) {
+        this.cleanupSshPackagedPlugin(execution, sshPackagedPlugin.remotePath)
+      }
       throw error
     }
   }
@@ -461,6 +515,125 @@ export class WorkspaceManager {
     })
   }
 
+  private async getAvailablePort(): Promise<number> {
+    return await new Promise<number>((resolve, reject) => {
+      const server = createServer()
+      server.unref()
+      server.once("error", reject)
+      server.listen(0, "127.0.0.1", () => {
+        const address = server.address()
+        if (!address || typeof address === "string") {
+          server.close(() => reject(new Error("Failed to reserve a local port for SSH execution profile")))
+          return
+        }
+        const port = address.port
+        server.close((error) => {
+          if (error) {
+            reject(error)
+            return
+          }
+          resolve(port)
+        })
+      })
+    })
+  }
+
+  private async syncSshPackagedPlugin(
+    execution: Extract<ResolvedBinary, { kind: "ssh" }>,
+    workspaceId: string,
+    configContent: string | undefined,
+  ): Promise<SshPackagedPluginArtifact | undefined> {
+    const packagedPlugin = findPackagedCodeNomadPluginReference(configContent)
+    if (!packagedPlugin || !configContent) {
+      return undefined
+    }
+
+    const localPluginPath = path.normalize(packagedPlugin.filePath)
+    const remotePluginPath = `/tmp/codenomad-opencode-plugin-${workspaceId}.tgz`
+    const sshArgs = this.buildSshCommandArgs(execution, [
+      "sh",
+      "-lc",
+      `rm -f ${shellQuote(remotePluginPath)}`,
+    ])
+    const cleanupResult = spawnSync("ssh", sshArgs, {
+      encoding: "utf8",
+      maxBuffer: 10 * 1024 * 1024,
+    })
+    if (cleanupResult.error) {
+      throw cleanupResult.error
+    }
+    if (cleanupResult.status !== 0) {
+      throw new Error(`Failed to prepare SSH OpenCode plugin path: ${cleanupResult.stderr || `ssh exited with ${cleanupResult.status}`}`)
+    }
+
+    const scpResult = spawnSync(
+      "scp",
+      this.buildScpCommandArgs(execution, [localPluginPath, `${this.buildSshTarget(execution)}:${remotePluginPath}`]),
+      {
+        encoding: "utf8",
+        maxBuffer: 10 * 1024 * 1024,
+      },
+    )
+    if (scpResult.error) {
+      throw scpResult.error
+    }
+    if (scpResult.status !== 0) {
+      throw new Error(`Failed to copy OpenCode plugin to SSH host: ${scpResult.stderr || `scp exited with ${scpResult.status}`}`)
+    }
+
+    return {
+      remotePath: remotePluginPath,
+      configContent: rewritePackagedCodeNomadPluginReference(configContent, remotePluginPath),
+    }
+  }
+
+  private cleanupSshPackagedPlugin(execution: Extract<ResolvedBinary, { kind: "ssh" }>, remotePluginPath: string): void {
+    const result = spawnSync("ssh", this.buildSshCommandArgs(execution, ["sh", "-lc", `rm -f ${shellQuote(remotePluginPath)}`]), {
+      encoding: "utf8",
+      timeout: 10_000,
+    })
+    if (result.error || result.status !== 0) {
+      this.options.logger.debug({ err: result.error, stderr: result.stderr, status: result.status }, "Failed to clean SSH OpenCode plugin path")
+    }
+  }
+
+  private buildSshCommandArgs(execution: Extract<ResolvedBinary, { kind: "ssh" }>, remoteArgs: string[]): string[] {
+    return [
+      "-p",
+      String(execution.port ?? 22),
+      "-o",
+      "BatchMode=yes",
+      "-o",
+      "ExitOnForwardFailure=yes",
+      this.buildSshTarget(execution),
+      ...remoteArgs,
+    ]
+  }
+
+  private buildScpCommandArgs(execution: Extract<ResolvedBinary, { kind: "ssh" }>, args: string[]): string[] {
+    return [
+      "-P",
+      String(execution.port ?? 22),
+      "-o",
+      "BatchMode=yes",
+      ...args,
+    ]
+  }
+
+  private buildSshTarget(execution: Extract<ResolvedBinary, { kind: "ssh" }>): string {
+    const host = execution.host.trim()
+    if (!host || host.startsWith("-") || /\s/.test(host)) {
+      throw new Error("SSH host must not be empty, start with '-', or contain whitespace")
+    }
+
+    const username = execution.username?.trim()
+    if (username && (username.startsWith("-") || /[@\s]/.test(username))) {
+      throw new Error("SSH username must not start with '-' or contain '@' or whitespace")
+    }
+
+    return username ? `${username}@${host}` : host
+  }
+
   private delay(durationMs: number): Promise<void> {
     if (durationMs <= 0) {
       return Promise.resolve()
diff --git a/packages/server/src/workspaces/runtime.ts b/packages/server/src/workspaces/runtime.ts
index efc77f9a1..0f597d428 100644
--- a/packages/server/src/workspaces/runtime.ts
+++ b/packages/server/src/workspaces/runtime.ts
@@ -4,10 +4,9 @@ import path from "path"
 import { EventBus } from "../events/bus"
 import { LogLevel, WorkspaceLogEntry } from "../api-types"
 import { Logger } from "../logger"
-import { buildSpawnSpec, buildWslSignalSpec } from "./spawn"
+import { buildSpawnSpec, buildWslSignalSpec, WSL_PID_MARKER } from "./spawn"
 
-const SENSITIVE_ENV_KEY = /(PASSWORD|TOKEN|SECRET)/i
-const WSL_PID_MARKER = "__CODENOMAD_WSL_PID__:"
+const SENSITIVE_ENV_KEY = /(PASSWORD|TOKEN|SECRET|API[_-]?KEY)/i
 
 function redactEnvironment(env: Record<string, string | undefined>): Record<string, string | undefined> {
   const redacted: Record<string, string | undefined> = {}
@@ -21,11 +20,31 @@ function redactEnvironment(env: Record<string, string | undefined>): Record<stri
   return redacted
 }
 
+function redactArgs(args: string[]): string[] {
+  return args.map((arg, index) => {
+    const [key] = arg.split("=", 1)
+    if (key && SENSITIVE_ENV_KEY.test(key)) {
+      return arg.includes("=") ? `${key}=[REDACTED]` : "[REDACTED]"
+    }
+
+    const previous = args[index - 1]
+    if ((previous === "-e" || previous === "--env") && SENSITIVE_ENV_KEY.test(key ?? arg)) {
+      return arg.includes("=") ? `${key}=[REDACTED]` : arg
+    }
+
+    return arg
+  })
+}
+
 interface LaunchOptions {
   workspaceId: string
   folder: string
   binaryPath: string
+  commandArgs?: string[]
+  spawnCwd?: string
   environment?: Record<string, string>
+  wslDistro?: string
+  stdin?: string
   logLevel?: string
   onExit?: (info: ProcessExitInfo) => void
 }
@@ -55,7 +74,7 @@ export class WorkspaceRuntime {
     this.validateFolder(options.folder)
 
     const logLevel = typeof options.logLevel === "string" ? options.logLevel.toUpperCase() : "DEBUG"
-    const args = ["serve", "--port", "0", "--print-logs", "--log-level", logLevel]
+    const args = options.commandArgs ?? ["serve", "--port", "0", "--print-logs", "--log-level", logLevel]
     const env = { ...process.env, ...(options.environment ?? {}) }
 
     let exitResolve: ((info: ProcessExitInfo) => void) | null = null
@@ -83,12 +102,14 @@ export class WorkspaceRuntime {
     return new Promise((resolve, reject) => {
       const propagatedEnvKeys = Object.keys(options.environment ?? {})
       const spec = buildSpawnSpec(options.binaryPath, args, {
-        cwd: options.folder,
+        cwd: options.spawnCwd ?? options.folder,
         env,
         propagateEnvKeys: propagatedEnvKeys,
         wslPidMarker: WSL_PID_MARKER,
+        wslDistro: options.wslDistro,
       })
-      const commandLine = [spec.command, ...spec.args].join(" ")
+      const redactedArgs = redactArgs(spec.args)
+      const commandLine = [spec.command, ...redactedArgs].join(" ")
       this.logger.info(
         {
           workspaceId: options.workspaceId,
@@ -103,7 +124,7 @@ export class WorkspaceRuntime {
       this.logger.debug(
         {
           workspaceId: options.workspaceId,
-          spawnArgs: spec.args,
+          spawnArgs: redactedArgs,
         },
         "OpenCode spawn args",
       )
@@ -119,11 +140,15 @@ export class WorkspaceRuntime {
       const child = spawn(spec.command, spec.args, {
         cwd: spec.cwd,
         env: spec.env,
-        stdio: ["ignore", "pipe", "pipe"],
+        stdio: [options.stdin === undefined ? "ignore" : "pipe", "pipe", "pipe"],
         detached,
         ...spec.options,
       })
 
+      if (options.stdin !== undefined) {
+        child.stdin?.end(options.stdin)
+      }
+
       const managed: ManagedProcess = {
         child,
         requestedStop: false,
diff --git a/packages/server/src/workspaces/spawn.ts b/packages/server/src/workspaces/spawn.ts
index f40dcdb02..0e3416959 100644
--- a/packages/server/src/workspaces/spawn.ts
+++ b/packages/server/src/workspaces/spawn.ts
@@ -3,6 +3,7 @@ import path from "path"
 
 export const WINDOWS_CMD_EXTENSIONS = new Set([".cmd", ".bat"])
 export const WINDOWS_POWERSHELL_EXTENSIONS = new Set([".ps1"])
+export const WSL_PID_MARKER = "__CODENOMAD_WSL_PID__:"
 
 const VERSION_REGEX = /([0-9]+\.[0-9]+\.[0-9A-Za-z.-]+)/
 const WSL_UNC_PATH_REGEX = /^\\\\wsl(?:\.localhost|\$)\\([^\\/]+)(?:[\\/](.*))?$/i
@@ -33,6 +34,7 @@ interface BuildSpawnSpecOptions {
   env?: NodeJS.ProcessEnv
   propagateEnvKeys?: string[]
   wslPidMarker?: string
+  wslDistro?: string
 }
 
 interface WslPath {
@@ -77,6 +79,11 @@ export function buildWindowsSpawnSpec(binaryPath: string, args: string[], option
     return buildWslSpawnSpec(wslPath, args, options)
   }
 
+  const wslDistro = options.wslDistro?.trim()
+  if (wslDistro) {
+    return buildWslSpawnSpec({ distro: wslDistro, linuxPath: binaryPath }, args, options)
+  }
+
   const extension = path.extname(binaryPath).toLowerCase()
 
   if (WINDOWS_CMD_EXTENSIONS.has(extension)) {
@@ -137,7 +144,7 @@ export function buildWslSignalSpec(distro: string, linuxPid: number, signal: Nod
   }
 }
 
-export function probeBinaryVersion(binaryPath: string): {
+export function probeBinaryVersion(binaryPath: string, options: { wslDistro?: string } = {}): {
   valid: boolean
   version?: string
   reported?: string
@@ -148,7 +155,7 @@ export function probeBinaryVersion(binaryPath: string): {
   }
 
   try {
-    const spec = buildSpawnSpec(binaryPath, ["--version"])
+    const spec = buildSpawnSpec(binaryPath, ["--version"], { wslDistro: options.wslDistro })
     const result = spawnSync(spec.command, spec.args, {
       encoding: "utf8",
       cwd: spec.cwd,
diff --git a/packages/ui/src/App.tsx b/packages/ui/src/App.tsx
index 2aa430fcd..ed7e10490 100644
--- a/packages/ui/src/App.tsx
+++ b/packages/ui/src/App.tsx
@@ -264,7 +264,7 @@ const App: Component = () => {
 
   const launchErrorMessage = () => launchError()?.message ?? ""
 
-  async function handleSelectFolder(folderPath: string, binaryPath?: string, options?: { forceNew?: boolean }) {
+  async function handleSelectFolder(folderPath: string, binaryPath?: string, options?: { executionProfileId?: string; forceNew?: boolean }) {
     if (!folderPath) {
       return
     }
@@ -282,7 +282,9 @@ const App: Component = () => {
 
     setIsSelectingFolder(true)
     try {
-      const instanceId = await createInstance(folderPath, selectedBinary)
+      const instanceId = await createInstance(folderPath, selectedBinary, {
+        executionProfileId: options?.executionProfileId,
+      })
       selectInstanceTab(instanceId)
       setShowFolderSelection(false)
 
diff --git a/packages/ui/src/components/action-overflow-menu.tsx b/packages/ui/src/components/action-overflow-menu.tsx
new file mode 100644
index 000000000..a66a25f3f
--- /dev/null
+++ b/packages/ui/src/components/action-overflow-menu.tsx
@@ -0,0 +1,85 @@
+import { DropdownMenu } from "@kobalte/core/dropdown-menu"
+import { For, Show, createSignal, onCleanup, type JSXElement } from "solid-js"
+import { MoreHorizontal } from "lucide-solid"
+
+export interface ActionOverflowMenuItem {
+  key: string
+  label: string
+  icon?: JSXElement
+  disabled?: boolean
+  destructive?: boolean
+  onSelect: () => void | Promise<void>
+  onMouseEnter?: () => void
+  onMouseLeave?: () => void
+}
+
+interface ActionOverflowMenuProps {
+  items: ActionOverflowMenuItem[]
+  label: string
+  triggerClass?: string
+  minItems?: number
+}
+
+export default function ActionOverflowMenu(props: ActionOverflowMenuProps) {
+  const [hoveredItem, setHoveredItem] = createSignal<ActionOverflowMenuItem | null>(null)
+  const enabledItems = () => props.items.filter((item) => !item.disabled)
+  const hasItems = () => props.items.length >= (props.minItems ?? 1)
+  const clearHoveredItem = () => {
+    const item = hoveredItem()
+    if (!item) return
+    item.onMouseLeave?.()
+    setHoveredItem(null)
+  }
+
+  onCleanup(clearHoveredItem)
+
+  return (
+    <Show when={hasItems()}>
+      <DropdownMenu placement="bottom-end" gutter={4} onOpenChange={(open) => { if (!open) clearHoveredItem() }}>
+        <DropdownMenu.Trigger
+          class={`action-overflow-trigger ${props.triggerClass ?? ""}`.trim()}
+          aria-label={props.label}
+          title={props.label}
+          disabled={enabledItems().length === 0}
+        >
+          <MoreHorizontal class="w-3.5 h-3.5" aria-hidden="true" />
+        </DropdownMenu.Trigger>
+
+        <DropdownMenu.Portal>
+          <DropdownMenu.Content class="action-overflow-content">
+            <For each={props.items}>
+              {(item) => (
+                <DropdownMenu.Item
+                  class="action-overflow-item"
+                  data-destructive={item.destructive ? "true" : undefined}
+                  disabled={item.disabled}
+                  onPointerEnter={() => {
+                    if (item.disabled) return
+                    const previous = hoveredItem()
+                    if (previous !== item) previous?.onMouseLeave?.()
+                    setHoveredItem(item)
+                    item.onMouseEnter?.()
+                  }}
+                  onPointerLeave={() => {
+                    if (item.disabled) return
+                    if (hoveredItem() === item) setHoveredItem(null)
+                    item.onMouseLeave?.()
+                  }}
+                  onSelect={() => {
+                    clearHoveredItem()
+                    void item.onSelect()
+                  }}
+                >
+                  <Show when={item.icon} fallback={<span class="action-overflow-item-icon" aria-hidden="true" />}>
+                    {(icon) => <span class="action-overflow-item-icon" aria-hidden="true">{icon()}</span>}
+                  </Show>
+                  <span class="action-overflow-item-label">{item.label}</span>
+                </DropdownMenu.Item>
+              )}
+            </For>
+          </DropdownMenu.Content>
+        </DropdownMenu.Portal>
+      </DropdownMenu>
+    </Show>
+  )
+}
diff --git a/packages/ui/src/components/folder-selection-view.tsx b/packages/ui/src/components/folder-selection-view.tsx
index 035efb708..ff4fecdb0 100644
--- a/packages/ui/src/components/folder-selection-view.tsx
+++ b/packages/ui/src/components/folder-selection-view.tsx
@@ -1,6 +1,7 @@
 import { Dialog } from "@kobalte/core/dialog"
 import { Select } from "@kobalte/core/select"
-import { Component, createMemo, createSignal, Show, For, onMount, onCleanup, createEffect } from "solid-js"
+import type { RemoteServerProfile } from "../../../server/src/api-types"
+import { Component, createSignal, Show, For, onMount, onCleanup, createEffect, createMemo } from "solid-js"
 import { Folder, Clock, Trash2, FolderPlus, Settings, ChevronRight, MonitorUp, Star, Languages, ChevronDown, X, Globe, Loader2, GitBranch } from "lucide-solid"
 import { useConfig } from "../stores/preferences"
 import DirectoryBrowserDialog from "./directory-browser-dialog"
@@ -26,9 +27,8 @@ const DISCORD_URL = "https://discord.com/channels/1391832426048651334/1458412028
 
 type HomeTab = "local" | "servers"
 
-
 interface FolderSelectionViewProps {
-  onSelectFolder: (folder: string, binaryPath?: string, options?: { forceNew?: boolean }) => void
+  onSelectFolder: (folder: string, binaryPath?: string, options?: { executionProfileId?: string; forceNew?: boolean }) => void
   onOpenSidecar?: () => void
   isLoading?: boolean
   onClose?: () => void
@@ -41,6 +41,10 @@ const FolderSelectionView: Component<FolderSelectionViewProps> = (props) => {
     preferences,
     updatePreferences,
     serverSettings,
+    executionProfiles,
+    defaultExecutionProfileId,
+    lastSelectedExecutionProfileId,
+    setLastSelectedExecutionProfileId,
     remoteServers,
     saveRemoteServerProfile,
     markRemoteServerConnected,
@@ -50,6 +54,7 @@ const FolderSelectionView: Component<FolderSelectionViewProps> = (props) => {
   const [selectedIndex, setSelectedIndex] = createSignal(0)
   const [focusMode, setFocusMode] = createSignal<"recent" | "new" | null>("recent")
   const [selectedBinary, setSelectedBinary] = createSignal(serverSettings().opencodeBinary || "opencode")
+  const [selectedExecutionProfileId, setSelectedExecutionProfileId] = createSignal<string | null>(lastSelectedExecutionProfileId() ?? defaultExecutionProfileId() ?? null)
   const [isFolderBrowserOpen, setIsFolderBrowserOpen] = createSignal(false)
   const [isCloneDialogOpen, setIsCloneDialogOpen] = createSignal(false)
   const [isCloneDestinationBrowserOpen, setIsCloneDestinationBrowserOpen] = createSignal(false)
@@ -69,6 +74,7 @@ const FolderSelectionView: Component<FolderSelectionViewProps> = (props) => {
   let recentListRef: HTMLDivElement | undefined
 
   type LanguageOption = { value: Locale; label: string }
+  type ExecutionProfileOption = { value: string; label: string; subtitle: string }
 
   const languageOptions: LanguageOption[] = [
     { value: "en", label: "English" },
@@ -81,6 +87,18 @@ const FolderSelectionView: Component<FolderSelectionViewProps> = (props) => {
   ]
 
   const selectedLanguageOption = () => languageOptions.find((opt) => opt.value === locale()) ?? languageOptions[0]
+  const executionProfileOptions = createMemo<ExecutionProfileOption[]>(() =>
+    executionProfiles().map((profile) => ({
+      value: profile.id,
+      label: profile.name,
+      subtitle: t(`settings.opencode.executionProfiles.kind.${profile.kind}`),
+    })),
+  )
+  const selectedExecutionProfileOption = createMemo(() => {
+    const options = executionProfileOptions()
+    const selectedId = selectedExecutionProfileId()
+    return options.find((option) => option.value === selectedId) ?? options[0]
+  })
   
   const folders = () => recentFolders()
   const serverList = () => remoteServers()
@@ -98,6 +116,34 @@ const FolderSelectionView: Component<FolderSelectionViewProps> = (props) => {
     setSelectedBinary((current) => (current === lastUsed ? current : lastUsed))
   })
 
+  createEffect(() => {
+    const options = executionProfileOptions()
+    if (options.length === 0) {
+      setSelectedExecutionProfileId(null)
+      return
+    }
+
+    const defaultId = defaultExecutionProfileId()
+    const selectedId = selectedExecutionProfileId()
+    const targetId =
+      selectedId && options.some((option) => option.value === selectedId)
+        ? selectedId
+        : lastSelectedExecutionProfileId() && options.some((option) => option.value === lastSelectedExecutionProfileId())
+          ? lastSelectedExecutionProfileId()!
+        : defaultId && options.some((option) => option.value === defaultId)
+          ? defaultId
+          : options[0]?.value
+
+    setSelectedExecutionProfileId((current) => (current === targetId ? current : targetId ?? null))
+  })
+
+  createEffect(() => {
+    const selectedId = selectedExecutionProfileId()
+    if (!selectedId) return
+    if (lastSelectedExecutionProfileId() === selectedId) return
+    setLastSelectedExecutionProfileId(selectedId)
+  })
+
 
   function scrollToIndex(index: number) {
     const container = recentListRef
@@ -208,7 +254,7 @@ const FolderSelectionView: Component<FolderSelectionViewProps> = (props) => {
 
     const server = serverList()[index]
     if (server) {
-      void handleConnectSavedServer(server.id)
+      void handleConnectSavedConnection(server.id)
     }
   }
 
@@ -281,7 +327,9 @@ const FolderSelectionView: Component<FolderSelectionViewProps> = (props) => {
 
   function handleFolderSelect(path: string) {
     if (isLoading()) return
-    props.onSelectFolder(path, selectedBinary())
+    props.onSelectFolder(path, selectedBinary(), {
+      executionProfileId: selectedExecutionProfileId() ?? undefined,
+    })
   }
 
   function resetCloneDialog() {
@@ -339,7 +387,7 @@ const FolderSelectionView: Component<FolderSelectionViewProps> = (props) => {
 
   async function probeAndOpenServer(input: { id?: string; name: string; baseUrl: string; skipTlsVerify: boolean }, openWindow: boolean) {
     if (openWindow && !canUseRemoteServerWindows()) {
-      throw new Error("Remote server windows can only be opened from a local desktop window")
+      throw new Error(t("folderSelection.servers.errorDesktopOnly"))
     }
 
     const trimmedName = input.name.trim()
@@ -410,7 +458,7 @@ const FolderSelectionView: Component<FolderSelectionViewProps> = (props) => {
     }
   }
 
-  async function handleConnectSavedServer(id: string) {
+  async function handleConnectSavedConnection(id: string) {
     if (!canUseRemoteServerWindows()) return
     const target = remoteServers().find((entry) => entry.id === id)
     if (!target || connectingServerId()) return
@@ -427,6 +475,10 @@ const FolderSelectionView: Component<FolderSelectionViewProps> = (props) => {
     }
   }
 
+  async function handleRemoveSavedConnection(profile: RemoteServerProfile) {
+    removeRemoteServerProfile(profile.id)
+  }
+
   async function handleBrowse() {
     if (isLoading()) return
     setFocusMode("new")
@@ -762,7 +814,7 @@ const FolderSelectionView: Component<FolderSelectionViewProps> = (props) => {
                               color: activeTab() === "servers" ? "var(--text-muted)" : "var(--text-secondary)",
                             }}
                           >
-                            {t("folderSelection.servers.count", { count: remoteServers().length })}
+                            {t("folderSelection.servers.count", { count: serverList().length })}
                           </p>
                         </button>
                       </Show>
@@ -773,7 +825,7 @@ const FolderSelectionView: Component<FolderSelectionViewProps> = (props) => {
                     when={activeTab() === "local"}
                     fallback={
                       <Show
-                        when={canUseRemoteServerWindows() && remoteServers().length > 0}
+                        when={canUseRemoteServerWindows() && serverList().length > 0}
                         fallback={
                           <Show when={canUseRemoteServerWindows()}>
                             <div class="panel-empty-state flex-1">
@@ -798,7 +850,7 @@ const FolderSelectionView: Component<FolderSelectionViewProps> = (props) => {
                           class="panel-list panel-list--fill flex-1 min-h-0 overflow-auto"
                           ref={(el) => (recentListRef = el)}
                         >
-                          <For each={remoteServers()}>
+                          <For each={serverList()}>
                             {(server, index) => (
                               <div
                                 class="panel-list-item"
@@ -810,7 +862,7 @@ const FolderSelectionView: Component<FolderSelectionViewProps> = (props) => {
                                   <button
                                     data-list-index={index()}
                                     class="panel-list-item-content flex-1"
-                                    onClick={() => void handleConnectSavedServer(server.id)}
+                                    onClick={() => void handleConnectSavedConnection(server.id)}
                                     onMouseEnter={() => {
                                       setFocusMode("recent")
                                       setSelectedIndex(index())
@@ -821,10 +873,22 @@ const FolderSelectionView: Component<FolderSelectionViewProps> = (props) => {
                                         <div class="flex items-center gap-2 mb-1">
                                           <Globe class="w-4 h-4 flex-shrink-0 icon-muted" />
                                           <span class="text-sm font-medium truncate text-primary">{server.name}</span>
+                                          <span class="text-[10px] uppercase text-muted">
+                                            {t("folderSelection.servers.kind.remoteServer")}
+                                          </span>
                                         </div>
                                         <div class="flex items-center gap-2 pl-6 text-xs text-muted min-w-0">
-                                          <span class="font-mono truncate-start flex-1 min-w-0">{server.baseUrl}</span>
+                                          <span class="font-mono truncate-start flex-1 min-w-0">
+                                            {server.baseUrl}
+                                          </span>
                                         </div>
+                                        <Show when={server.lastConnectedAt}>
+                                          {(lastConnectedAt) => (
+                                            <div class="pl-6 text-[11px] text-muted mt-1">
+                                              {t("folderSelection.servers.lastConnected", { time: formatRelativeTime(new Date(lastConnectedAt()).getTime()) })}
+                                            </div>
+                                          )}
+                                        </Show>
                                       </div>
                                       <Show when={connectingServerId() === server.id} fallback={<Show when={focusMode() === "recent" && selectedIndex() === index()}><kbd class="kbd">↵</kbd></Show>}>
                                         <Loader2 class="w-4 h-4 animate-spin icon-muted" />
@@ -832,7 +896,7 @@ const FolderSelectionView: Component<FolderSelectionViewProps> = (props) => {
                                     </div>
                                   </button>
                                   <button
-                                    onClick={() => removeRemoteServerProfile(server.id)}
+                                    onClick={() => void handleRemoveSavedConnection(server)}
                                     class="p-2 transition-all hover:bg-red-100 dark:hover:bg-red-900/30 opacity-70 hover:opacity-100 rounded"
                                     title={t("folderSelection.servers.remove")}
                                   >
@@ -937,7 +1001,58 @@ const FolderSelectionView: Component<FolderSelectionViewProps> = (props) => {
                   <p class="panel-subtitle">{t("folderSelection.actions.subtitle")}</p>
                 </div>
 
-                <div class="panel-body flex flex-col gap-3">
+                 <div class="panel-body flex flex-col gap-3">
+                  <Show when={executionProfileOptions().length > 0}>
+                    <div class="flex flex-col gap-2">
+                      <div>
+                        <div class="text-sm font-medium text-secondary">{t("folderSelection.executionProfile.label")}</div>
+                        <div class="text-xs text-muted">{t("folderSelection.executionProfile.subtitle")}</div>
+                      </div>
+                      <Select<ExecutionProfileOption>
+                        value={selectedExecutionProfileOption()}
+                        onChange={(option) => {
+                          if (!option) return
+                          setSelectedExecutionProfileId(option.value)
+                        }}
+                        options={executionProfileOptions()}
+                        optionValue="value"
+                        optionTextValue="label"
+                        itemComponent={(itemProps) => (
+                          <Select.Item item={itemProps.item} class="selector-option">
+                            <div class="flex flex-col">
+                              <Select.ItemLabel class="selector-option-label">{itemProps.item.rawValue.label}</Select.ItemLabel>
+                              <span class="text-xs text-muted uppercase">{itemProps.item.rawValue.subtitle}</span>
+                            </div>
+                          </Select.Item>
+                        )}
+                      >
+                        <Select.Trigger class="selector-trigger" aria-label={t("folderSelection.executionProfile.label")}>
+                          <div class="flex-1 min-w-0 text-left">
+                            <Select.Value<ExecutionProfileOption>>
+                              {(state) => (
+                                <div class="flex flex-col min-w-0">
+                                  <span class="selector-trigger-primary selector-trigger-primary--align-left">
+                                    {state.selectedOption()?.label}
+                                  </span>
+                                  <span class="text-xs text-muted uppercase">{state.selectedOption()?.subtitle}</span>
+                                </div>
+                              )}
+                            </Select.Value>
+                          </div>
+                          <Select.Icon class="selector-trigger-icon">
+                            <ChevronDown class="w-3 h-3" />
+                          </Select.Icon>
+                        </Select.Trigger>
+
+                        <Select.Portal>
+                          <Select.Content class="selector-popover">
+                            <Select.Listbox class="selector-listbox" />
+                          </Select.Content>
+                        </Select.Portal>
+                      </Select>
+                    </div>
+                  </Show>
+
                   <button
                     onClick={() => void handleBrowse()}
                     disabled={props.isLoading}
@@ -1241,6 +1356,7 @@ const FolderSelectionView: Component<FolderSelectionViewProps> = (props) => {
           </div>
         </Dialog.Portal>
       </Dialog>
+
     </>
   )
 }
diff --git a/packages/ui/src/components/instance-info.tsx b/packages/ui/src/components/instance-info.tsx
index 8f9c893c1..5cfbbb22a 100644
--- a/packages/ui/src/components/instance-info.tsx
+++ b/packages/ui/src/components/instance-info.tsx
@@ -144,6 +144,17 @@ const InstanceInfo: Component<InstanceInfoProps> = (props) => {
           </div>
         </Show>
 
+        <Show when={currentInstance().executionProfileName}>
+          <div>
+            <div class="text-xs font-medium text-muted uppercase tracking-wide mb-1">
+              {t("instanceInfo.labels.executionProfile")}
+            </div>
+            <div class="text-xs px-2 py-1.5 rounded border bg-surface-secondary border-base text-primary">
+              {currentInstance().executionProfileName}
+            </div>
+          </div>
+        </Show>
+
         <Show when={environmentEntries().length > 0}>
           <div>
             <div class="text-xs font-medium text-muted uppercase tracking-wide mb-1.5">
diff --git a/packages/ui/src/components/message-block.tsx b/packages/ui/src/components/message-block.tsx
index 04c15e7ac..07d6a9af7 100644
--- a/packages/ui/src/components/message-block.tsx
+++ b/packages/ui/src/components/message-block.tsx
@@ -1,5 +1,5 @@
 import { For, Index, Match, Show, Suspense, Switch, createEffect, createMemo, createSignal, lazy, onCleanup, untrack, type Accessor } from "solid-js"
-import { ChevronsDownUp, ChevronsUpDown, ExternalLink, FoldVertical, ListStart, Trash } from "lucide-solid"
+import { ChevronsDownUp, ChevronsUpDown, ExternalLink, FoldVertical, ListStart, Trash, Volume2 } from "lucide-solid"
 import MessageItem from "./message-item"
 import type { InstanceMessageStore } from "../stores/message-v2/instance-store"
 import type { ClientPart, MessageInfo } from "../types/message"
@@ -18,6 +18,7 @@ import { useSpeech } from "../lib/hooks/use-speech"
 import SpeechActionButton from "./speech-action-button"
 import { createFollowScroll } from "../lib/follow-scroll"
 import type { SessionSearchMatch } from "../lib/session-search"
+import ActionOverflowMenu, { type ActionOverflowMenuItem } from "./action-overflow-menu"
 
 function DeleteUpToIcon() {
   return (
@@ -486,6 +487,12 @@ function ToolCallItem(props: ToolCallItemProps) {
     navigateToTaskSession(location)
   }
 
+  const goToTaskSession = () => {
+    const location = taskLocation()
+    if (!location) return
+    navigateToTaskSession(location)
+  }
+
   const handleDeleteMessage = async (event: MouseEvent) => {
     event.preventDefault()
     event.stopPropagation()
@@ -507,9 +514,7 @@ function ToolCallItem(props: ToolCallItemProps) {
     }
   }
 
-  const handleDeleteUpTo = async (event: MouseEvent) => {
-    event.preventDefault()
-    event.stopPropagation()
+  const deleteUpTo = async () => {
     if (!props.showDeleteMessage) return
     if (!props.onDeleteMessagesUpTo) return
     if (deletingUpTo()) return
@@ -522,11 +527,72 @@ function ToolCallItem(props: ToolCallItemProps) {
     }
   }
 
+  const handleDeleteUpTo = async (event: MouseEvent) => {
+    event.preventDefault()
+    event.stopPropagation()
+    await deleteUpTo()
+  }
+
+  const actionMenuItems = (): ActionOverflowMenuItem[] => {
+    const items: ActionOverflowMenuItem[] = []
+
+    if (taskSessionId()) {
+      items.push({
+        key: "go-to-session",
+        label: t("messageBlock.tool.goToSession.label"),
+        icon: <ExternalLink class="w-3.5 h-3.5" aria-hidden="true" />,
+        disabled: !taskLocation(),
+        onSelect: goToTaskSession,
+      })
+    }
+
+    if (props.showDeleteMessage) {
+      items.push(
+        {
+          key: "delete-up-to",
+          label: t("messageItem.actions.deleteMessagesUpTo"),
+          icon: <DeleteUpToIcon />,
+          disabled: !props.onDeleteMessagesUpTo || deletingUpTo(),
+          destructive: true,
+          onMouseEnter: () => props.onDeleteHoverChange?.({ kind: "deleteUpTo", messageId: props.messageId }),
+          onMouseLeave: () => props.onDeleteHoverChange?.({ kind: "none" }),
+          onSelect: deleteUpTo,
+        },
+        {
+          key: "delete-message",
+          label: deletingMessage() ? t("messageItem.actions.deletingMessage") : t("messageItem.actions.deleteMessage"),
+          icon: <Trash class="w-3.5 h-3.5" aria-hidden="true" />,
+          disabled: deletingMessage(),
+          destructive: true,
+          onMouseEnter: () => props.onDeleteHoverChange?.({ kind: "message", messageId: props.messageId }),
+          onMouseLeave: () => props.onDeleteHoverChange?.({ kind: "none" }),
+          onSelect: async () => {
+            if (deletingMessage()) return
+            setDeletingMessage(true)
+            try {
+              await deleteMessage(props.instanceId, props.sessionId, props.messageId)
+            } catch (error) {
+              showAlertDialog(t("messageItem.actions.deleteMessageFailedMessage"), {
+                title: t("messageItem.actions.deleteMessageFailedTitle"),
+                detail: error instanceof Error ? error.message : String(error),
+                variant: "error",
+              })
+            } finally {
+              setDeletingMessage(false)
+            }
+          },
+        },
+      )
+    }
+
+    return items
+  }
+
   return (
     <Show when={toolPart()}>
       {(resolvedToolPart) => (
         <div class="delete-hover-scope" data-delete-part-hover={isDeleteOverlayActive() ? "true" : undefined}>
-          <div class="tool-call-header-label">
+          <div class="tool-call-header-label" data-action-overflow={actionMenuItems().length > 1 ? "true" : undefined}>
             <div class="tool-call-header-meta">
               <Show when={props.showDeleteMessage}>
                 <input
@@ -551,7 +617,7 @@ function ToolCallItem(props: ToolCallItemProps) {
               <span class="tool-name">{toolName() || t("messageBlock.tool.unknown")}</span>
             </div>
 
-            <div class="flex items-center gap-0">
+            <div class="tool-call-header-actions flex items-center gap-0">
               <Show when={taskSessionId()}>
                 <button
                   class="tool-call-header-button"
@@ -593,6 +659,12 @@ function ToolCallItem(props: ToolCallItemProps) {
                 </button>
               </Show>
             </div>
+            <ActionOverflowMenu
+              items={actionMenuItems()}
+              label={t("messageItem.actions.more")}
+              triggerClass="tool-call-header-button"
+              minItems={2}
+            />
           </div>
 
           <Suspense fallback={<ToolCallFallback />}>
@@ -1582,6 +1654,73 @@ function ReasoningCard(props: ReasoningCardProps) {
 
   const canDeleteMessage = () => Boolean(props.showDeleteMessage) && !deletingMessage()
 
+  const deleteUpTo = async () => {
+    if (!props.showDeleteMessage) return
+    if (!props.onDeleteMessagesUpTo) return
+    if (deletingUpTo()) return
+
+    setDeletingUpTo(true)
+    try {
+      await props.onDeleteMessagesUpTo(props.messageId)
+    } finally {
+      setDeletingUpTo(false)
+    }
+  }
+
+  const actionMenuItems = (): ActionOverflowMenuItem[] => {
+    const items: ActionOverflowMenuItem[] = []
+
+    if (canSpeakReasoning()) {
+      items.push({
+        key: "speak",
+        label: speech.buttonTitle(),
+        icon: <Volume2 class="w-3.5 h-3.5" aria-hidden="true" />,
+        onSelect: () => void speech.toggle(),
+      })
+    }
+
+    if (props.showDeleteMessage) {
+      items.push(
+        {
+          key: "delete-up-to",
+          label: t("messageItem.actions.deleteMessagesUpTo"),
+          icon: <DeleteUpToIcon />,
+          disabled: !props.onDeleteMessagesUpTo || deletingUpTo(),
+          destructive: true,
+          onMouseEnter: () => props.onDeleteHoverChange?.({ kind: "deleteUpTo", messageId: props.messageId }),
+          onMouseLeave: () => props.onDeleteHoverChange?.({ kind: "none" }),
+          onSelect: deleteUpTo,
+        },
+        {
+          key: "delete-message",
+          label: deletingMessage() ? t("messageItem.actions.deletingMessage") : t("messageItem.actions.deleteMessage"),
+          icon: <Trash class="w-3.5 h-3.5" aria-hidden="true" />,
+          disabled: !canDeleteMessage(),
+          destructive: true,
+          onMouseEnter: () => props.onDeleteHoverChange?.({ kind: "message", messageId: props.messageId }),
+          onMouseLeave: () => props.onDeleteHoverChange?.({ kind: "none" }),
+          onSelect: async () => {
+            if (!canDeleteMessage()) return
+            setDeletingMessage(true)
+            try {
+              await deleteMessage(props.instanceId, props.sessionId, props.messageId)
+            } catch (error) {
+              showAlertDialog(t("messageItem.actions.deleteMessageFailedMessage"), {
+                title: t("messageItem.actions.deleteMessageFailedTitle"),
+                detail: error instanceof Error ? error.message : String(error),
+                variant: "error",
+              })
+            } finally {
+              setDeletingMessage(false)
+            }
+          },
+        },
+      )
+    }
+
+    return items
+  }
+
   const handleDeleteMessage = async (event: MouseEvent) => {
     event.preventDefault()
     event.stopPropagation()
@@ -1604,16 +1743,7 @@ function ReasoningCard(props: ReasoningCardProps) {
   const handleDeleteUpTo = async (event: MouseEvent) => {
     event.preventDefault()
     event.stopPropagation()
-    if (!props.showDeleteMessage) return
-    if (!props.onDeleteMessagesUpTo) return
-    if (deletingUpTo()) return
-
-    setDeletingUpTo(true)
-    try {
-      await props.onDeleteMessagesUpTo(props.messageId)
-    } finally {
-      setDeletingUpTo(false)
-    }
+    await deleteUpTo()
   }
 
   return (
@@ -1654,7 +1784,7 @@ function ReasoningCard(props: ReasoningCardProps) {
           </span>
         </button>
 
-        <div class="message-reasoning-actions">
+        <div class="message-reasoning-actions" data-action-overflow={actionMenuItems().length > 1 ? "true" : undefined}>
           <Show when={canSpeakReasoning()}>
             <SpeechActionButton
               class="message-action-button"
@@ -1671,7 +1801,7 @@ function ReasoningCard(props: ReasoningCardProps) {
 
           <button
             type="button"
-            class="message-action-button"
+            class="message-action-button message-reasoning-primary-action"
             onClick={(event) => {
               event.preventDefault()
               event.stopPropagation()
@@ -1713,6 +1843,13 @@ function ReasoningCard(props: ReasoningCardProps) {
             </button>
           </Show>
 
+          <ActionOverflowMenu
+            items={actionMenuItems()}
+            label={t("messageItem.actions.more")}
+            triggerClass="message-action-button"
+            minItems={2}
+          />
+
           <span class="message-reasoning-time">{timestamp()}</span>
         </div>
       </div>
diff --git a/packages/ui/src/components/message-item.tsx b/packages/ui/src/components/message-item.tsx
index 1a6668510..00785441f 100644
--- a/packages/ui/src/components/message-item.tsx
+++ b/packages/ui/src/components/message-item.tsx
@@ -1,6 +1,6 @@
 import { For, Show, createEffect, createSignal, onCleanup } from "solid-js"
 import { Portal } from "solid-js/web"
-import { Copy, ListStart, Split, Trash, Undo } from "lucide-solid"
+import { Copy, ListStart, Split, Trash, Undo, Volume2 } from "lucide-solid"
 import type { MessageInfo, ClientPart, SDKAssistantMessageV2 } from "../types/message"
 import { isHiddenSyntheticTextPart, partHasRenderableText } from "../types/message"
 import type { MessageRecord } from "../stores/message-v2/types"
@@ -13,6 +13,7 @@ import { isTauriHost } from "../lib/runtime-env"
 import type { DeleteHoverState } from "../types/delete-hover"
 import { useSpeech } from "../lib/hooks/use-speech"
 import SpeechActionButton from "./speech-action-button"
+import ActionOverflowMenu, { type ActionOverflowMenuItem } from "./action-overflow-menu"
 
 function DeleteUpToIcon() {
   return (
@@ -388,6 +389,71 @@ export default function MessageItem(props: MessageItemProps) {
     return segments.join(" • ")
   }
 
+  const actionMenuItems = (): ActionOverflowMenuItem[] => {
+    const items: ActionOverflowMenuItem[] = [
+      {
+        key: "copy",
+        label: copyLabel(),
+        icon: <Copy class="w-3.5 h-3.5" aria-hidden="true" />,
+        onSelect: handleCopy,
+      },
+    ]
+
+    if (canSpeakMessage()) {
+      items.push({
+        key: "speak",
+        label: speech.buttonTitle(),
+        icon: <Volume2 class="w-3.5 h-3.5" aria-hidden="true" />,
+        onSelect: () => void speech.toggle(),
+      })
+    }
+
+    if (isUser() && props.onFork) {
+      items.push({
+        key: "fork",
+        label: t("messageItem.actions.fork"),
+        icon: <Split class="w-3.5 h-3.5" aria-hidden="true" />,
+        onSelect: () => props.onFork?.(props.record.id),
+      })
+    }
+
+    if (isUser() && props.onRevert) {
+      items.push({
+        key: "revert",
+        label: t("messageItem.actions.revertTitle"),
+        icon: <Undo class="w-3.5 h-3.5" aria-hidden="true" />,
+        onSelect: handleRevert,
+      })
+    }
+
+    if (props.showDeleteMessage) {
+      items.push(
+        {
+          key: "delete-up-to",
+          label: t("messageItem.actions.deleteMessagesUpTo"),
+          icon: <DeleteUpToIcon />,
+          disabled: !props.onDeleteMessagesUpTo || deletingUpTo(),
+          destructive: true,
+          onMouseEnter: () => props.onDeleteHoverChange?.({ kind: "deleteUpTo", messageId: props.record.id }),
+          onMouseLeave: () => props.onDeleteHoverChange?.({ kind: "none" }),
+          onSelect: () => void handleDeleteUpTo(),
+        },
+        {
+          key: "delete-message",
+          label: deletingMessage() ? t("messageItem.actions.deletingMessage") : t("messageItem.actions.deleteMessage"),
+          icon: <Trash class="w-3.5 h-3.5" aria-hidden="true" />,
+          disabled: deletingMessage(),
+          destructive: true,
+          onMouseEnter: () => props.onDeleteHoverChange?.({ kind: "message", messageId: props.record.id }),
+          onMouseLeave: () => props.onDeleteHoverChange?.({ kind: "none" }),
+          onSelect: handleDeleteMessage,
+        },
+      )
+    }
+
+    return items
+  }
+
 
   return (
     <div
@@ -440,7 +506,11 @@ export default function MessageItem(props: MessageItemProps) {
             </Show>
           </div>
 
-          <div class="message-item-actions" ref={(el) => (actionsEl = el)}>
+          <div
+            class="message-item-actions"
+            data-action-overflow={actionMenuItems().length > 1 ? "true" : undefined}
+            ref={(el) => (actionsEl = el)}
+          >
             <Show when={isUser()}>
               <div class="message-action-group">
                 <button
@@ -510,6 +580,12 @@ export default function MessageItem(props: MessageItemProps) {
                   </button>
                 </Show>
               </div>
+              <ActionOverflowMenu
+                items={actionMenuItems()}
+                label={t("messageItem.actions.more")}
+                triggerClass="message-action-button"
+                minItems={2}
+              />
             </Show>
             <Show when={!isUser()}>
               <div class="message-action-group">
@@ -558,6 +634,12 @@ export default function MessageItem(props: MessageItemProps) {
                   </button>
                 </Show>
               </div>
+              <ActionOverflowMenu
+                items={actionMenuItems()}
+                label={t("messageItem.actions.more")}
+                triggerClass="message-action-button"
+                minItems={2}
+              />
             </Show>
             <time class="message-timestamp" dateTime={timestampIso()}>{timestamp()}</time>
           </div>
diff --git a/packages/ui/src/components/settings/execution-profiles-settings-section.tsx b/packages/ui/src/components/settings/execution-profiles-settings-section.tsx
new file mode 100644
index 000000000..f8b55fb65
--- /dev/null
+++ b/packages/ui/src/components/settings/execution-profiles-settings-section.tsx
@@ -0,0 +1,622 @@
+import { createEffect, createMemo, createSignal, For, Show, type Component } from "solid-js"
+import { Copy, Pencil, Plus, Star, Trash2 } from "lucide-solid"
+import type { ExecutionProfile, ExecutionProfilePreviewResponse, ExecutionProfileTestResponse } from "../../../../server/src/api-types"
+import { serverApi } from "../../lib/api-client"
+import { useConfig } from "../../stores/preferences"
+import { useI18n } from "../../lib/i18n"
+
+function createProfileId(): string {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID()
+  }
+  return `exec-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`
+}
+
+function formatStringList(values?: string[]): string {
+  return values?.join("\n") ?? ""
+}
+
+function parseStringList(value: string): string[] | undefined {
+  const lines = value
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+  return lines.length > 0 ? lines : undefined
+}
+
+function buildProfileSummary(profile: ExecutionProfile): string {
+  switch (profile.kind) {
+    case "local":
+      return profile.binaryPath
+    case "wsl":
+      return `${profile.distro} · ${profile.binaryPath}`
+    case "docker":
+      return `${profile.image} · ${profile.workspaceMountPath}`
+    case "command":
+      return profile.executable
+    case "ssh":
+      return `${profile.username ? `${profile.username}@` : ""}${profile.host}${profile.port ? `:${profile.port}` : ""} · ${profile.remotePath}`
+  }
+}
+
+function formatPreviewEnvironment(environment: Record<string, string>): string {
+  return Object.entries(environment)
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([key, value]) => `${key}=${value}`)
+    .join("\n")
+}
+
+function duplicateProfile(profile: ExecutionProfile, nameSuffix: string): ExecutionProfile {
+  return {
+    ...profile,
+    id: createProfileId(),
+    name: `${profile.name} ${nameSuffix}`.trim(),
+  }
+}
+
+export const ExecutionProfilesSettingsSection: Component = () => {
+  const { t } = useI18n()
+  const {
+    executionProfiles,
+    defaultExecutionProfileId,
+    saveExecutionProfile,
+    setDefaultExecutionProfileId,
+    removeExecutionProfile,
+  } = useConfig()
+
+  const [editingId, setEditingId] = createSignal<string | null>(null)
+  const [kind, setKind] = createSignal<ExecutionProfile["kind"]>("local")
+  const [name, setName] = createSignal("")
+  const [binaryPath, setBinaryPath] = createSignal("")
+  const [distro, setDistro] = createSignal("")
+  const [image, setImage] = createSignal("")
+  const [workspaceMountPath, setWorkspaceMountPath] = createSignal("/workspace")
+  const [configMountPath, setConfigMountPath] = createSignal("/root/.config/opencode")
+  const [commandText, setCommandText] = createSignal("")
+  const [extraDockerArgsText, setExtraDockerArgsText] = createSignal("")
+  const [executable, setExecutable] = createSignal("")
+  const [argsText, setArgsText] = createSignal("")
+  const [cwdMode, setCwdMode] = createSignal<"workspace" | "inherit">("workspace")
+  const [sshHost, setSshHost] = createSignal("")
+  const [sshPort, setSshPort] = createSignal("22")
+  const [sshUsername, setSshUsername] = createSignal("")
+  const [sshRemotePath, setSshRemotePath] = createSignal("")
+  const [previewWorkspacePath, setPreviewWorkspacePath] = createSignal("")
+  const [saving, setSaving] = createSignal(false)
+  const [previewing, setPreviewing] = createSignal(false)
+  const [testing, setTesting] = createSignal(false)
+  const [formError, setFormError] = createSignal<string | null>(null)
+  const [previewError, setPreviewError] = createSignal<string | null>(null)
+  const [testError, setTestError] = createSignal<string | null>(null)
+  const [previewResult, setPreviewResult] = createSignal<ExecutionProfilePreviewResponse | null>(null)
+  const [testResult, setTestResult] = createSignal<ExecutionProfileTestResponse | null>(null)
+
+  const kindOptions = createMemo(() => [
+    { value: "local" as const, label: t("settings.opencode.executionProfiles.kind.local") },
+    { value: "wsl" as const, label: t("settings.opencode.executionProfiles.kind.wsl") },
+    { value: "docker" as const, label: t("settings.opencode.executionProfiles.kind.docker") },
+    { value: "command" as const, label: t("settings.opencode.executionProfiles.kind.command") },
+    { value: "ssh" as const, label: t("settings.opencode.executionProfiles.kind.ssh") },
+  ])
+
+  createEffect(() => {
+    kind()
+    name()
+    binaryPath()
+    distro()
+    image()
+    workspaceMountPath()
+    configMountPath()
+    commandText()
+    extraDockerArgsText()
+    executable()
+    argsText()
+    cwdMode()
+    sshHost()
+    sshPort()
+    sshUsername()
+    sshRemotePath()
+    previewWorkspacePath()
+    setPreviewError(null)
+    setTestError(null)
+    setPreviewResult(null)
+    setTestResult(null)
+  })
+
+  function resetForm(profile?: ExecutionProfile) {
+    setEditingId(profile?.id ?? null)
+    setKind(profile?.kind ?? "local")
+    setName(profile?.name ?? "")
+    setBinaryPath(profile?.kind === "local" || profile?.kind === "wsl" || profile?.kind === "ssh" ? profile.binaryPath : "")
+    setDistro(profile?.kind === "wsl" ? profile.distro : "")
+    setImage(profile?.kind === "docker" ? profile.image : "")
+    setWorkspaceMountPath(profile?.kind === "docker" ? profile.workspaceMountPath : "/workspace")
+    setConfigMountPath(profile?.kind === "docker" ? profile.configMountPath : "/root/.config/opencode")
+    setCommandText(profile?.kind === "docker" ? formatStringList(profile.command) : "")
+    setExtraDockerArgsText(profile?.kind === "docker" ? formatStringList(profile.extraDockerArgs) : "")
+    setExecutable(profile?.kind === "command" ? profile.executable : "")
+    setArgsText(profile?.kind === "command" || profile?.kind === "ssh" ? formatStringList(profile.args) : "")
+    setCwdMode(profile?.kind === "command" ? profile.cwdMode ?? "workspace" : "workspace")
+    setSshHost(profile?.kind === "ssh" ? profile.host : "")
+    setSshPort(profile?.kind === "ssh" ? String(profile.port ?? 22) : "22")
+    setSshUsername(profile?.kind === "ssh" ? profile.username ?? "" : "")
+    setSshRemotePath(profile?.kind === "ssh" ? profile.remotePath : "")
+    setPreviewWorkspacePath("")
+    setFormError(null)
+  }
+
+  function requireValue(value: string): string | null {
+    return value.trim().length > 0 ? value.trim() : null
+  }
+
+  function buildProfileFromForm(): ExecutionProfile {
+    const trimmedName = requireValue(name())
+    if (!trimmedName) {
+      throw new Error(t("settings.opencode.executionProfiles.validation.name"))
+    }
+
+    if (kind() === "local") {
+      const trimmedBinaryPath = requireValue(binaryPath())
+      if (!trimmedBinaryPath) {
+        throw new Error(t("settings.opencode.executionProfiles.validation.binaryPath"))
+      }
+      return {
+        id: editingId() ?? createProfileId(),
+        kind: "local",
+        name: trimmedName,
+        binaryPath: trimmedBinaryPath,
+      }
+    }
+
+    if (kind() === "wsl") {
+      const trimmedDistro = requireValue(distro())
+      const trimmedBinaryPath = requireValue(binaryPath())
+      if (!trimmedDistro) {
+        throw new Error(t("settings.opencode.executionProfiles.validation.distro"))
+      }
+      if (!trimmedBinaryPath) {
+        throw new Error(t("settings.opencode.executionProfiles.validation.binaryPath"))
+      }
+      return {
+        id: editingId() ?? createProfileId(),
+        kind: "wsl",
+        name: trimmedName,
+        distro: trimmedDistro,
+        binaryPath: trimmedBinaryPath,
+      }
+    }
+
+    if (kind() === "docker") {
+      const trimmedImage = requireValue(image())
+      const trimmedWorkspaceMountPath = requireValue(workspaceMountPath())
+      const trimmedConfigMountPath = requireValue(configMountPath())
+      if (!trimmedImage || !trimmedWorkspaceMountPath || !trimmedConfigMountPath) {
+        throw new Error(t("settings.opencode.executionProfiles.validation.docker"))
+      }
+      return {
+        id: editingId() ?? createProfileId(),
+        kind: "docker",
+        name: trimmedName,
+        image: trimmedImage,
+        workspaceMountPath: trimmedWorkspaceMountPath,
+        configMountPath: trimmedConfigMountPath,
+        command: parseStringList(commandText()),
+        extraDockerArgs: parseStringList(extraDockerArgsText()),
+      }
+    }
+
+    if (kind() === "ssh") {
+      const trimmedHost = requireValue(sshHost())
+      const trimmedRemotePath = requireValue(sshRemotePath())
+      const trimmedBinaryPath = requireValue(binaryPath())
+      const nextPort = sshPort().trim().length > 0 ? Number(sshPort()) : undefined
+      if (!trimmedHost) {
+        throw new Error(t("settings.opencode.executionProfiles.validation.sshHost"))
+      }
+      if (nextPort !== undefined && (!Number.isInteger(nextPort) || nextPort <= 0 || nextPort > 65535)) {
+        throw new Error(t("settings.opencode.executionProfiles.validation.sshPort"))
+      }
+      if (!trimmedRemotePath) {
+        throw new Error(t("settings.opencode.executionProfiles.validation.sshRemotePath"))
+      }
+      if (!trimmedBinaryPath) {
+        throw new Error(t("settings.opencode.executionProfiles.validation.binaryPath"))
+      }
+      return {
+        id: editingId() ?? createProfileId(),
+        kind: "ssh",
+        name: trimmedName,
+        host: trimmedHost,
+        port: nextPort,
+        username: sshUsername().trim() || undefined,
+        remotePath: trimmedRemotePath,
+        binaryPath: trimmedBinaryPath,
+        args: parseStringList(argsText()),
+      }
+    }
+
+    const trimmedExecutable = requireValue(executable())
+    if (!trimmedExecutable) {
+      throw new Error(t("settings.opencode.executionProfiles.validation.executable"))
+    }
+    return {
+      id: editingId() ?? createProfileId(),
+      kind: "command",
+      name: trimmedName,
+      executable: trimmedExecutable,
+      args: parseStringList(argsText()),
+      cwdMode: cwdMode(),
+    }
+  }
+
+  async function handleSave() {
+    let profile: ExecutionProfile
+    setFormError(null)
+    try {
+      profile = buildProfileFromForm()
+    } catch (error) {
+      setFormError(error instanceof Error ? error.message : String(error))
+      return
+    }
+
+    setSaving(true)
+    try {
+      await saveExecutionProfile(profile)
+      resetForm()
+    } catch (error) {
+      setFormError(error instanceof Error ? error.message : String(error))
+    } finally {
+      setSaving(false)
+    }
+  }
+
+  async function handlePreview() {
+    let profile: ExecutionProfile
+    setFormError(null)
+    setPreviewError(null)
+
+    try {
+      profile = buildProfileFromForm()
+    } catch (error) {
+      setFormError(error instanceof Error ? error.message : String(error))
+      return
+    }
+
+    setPreviewing(true)
+    try {
+      const result = await serverApi.previewExecutionProfile({
+        profile,
+        workspacePath: requireValue(previewWorkspacePath()) ?? undefined,
+      })
+      setPreviewResult(result)
+    } catch (error) {
+      setPreviewResult(null)
+      setPreviewError(error instanceof Error ? error.message : String(error))
+    } finally {
+      setPreviewing(false)
+    }
+  }
+
+  async function handleTest() {
+    let profile: ExecutionProfile
+    setFormError(null)
+    setTestError(null)
+
+    try {
+      profile = buildProfileFromForm()
+    } catch (error) {
+      setFormError(error instanceof Error ? error.message : String(error))
+      return
+    }
+
+    setTesting(true)
+    try {
+      const result = await serverApi.testExecutionProfile({
+        profile,
+        workspacePath: requireValue(previewWorkspacePath()) ?? undefined,
+      })
+      setPreviewResult(result)
+      setTestResult(result)
+    } catch (error) {
+      setTestResult(null)
+      setTestError(error instanceof Error ? error.message : String(error))
+    } finally {
+      setTesting(false)
+    }
+  }
+
+  async function handleDuplicate(profile: ExecutionProfile) {
+    setFormError(null)
+    try {
+      await saveExecutionProfile(duplicateProfile(profile, t("settings.common.duplicateSuffix")))
+    } catch (error) {
+      setFormError(error instanceof Error ? error.message : String(error))
+    }
+  }
+
+  return (
+    <div class="settings-section-stack">
+      <div class="settings-card">
+        <div class="settings-card-header">
+          <div>
+            <h3 class="settings-card-title">{t("settings.opencode.executionProfiles.title")}</h3>
+            <p class="settings-card-subtitle">{t("settings.opencode.executionProfiles.subtitle")}</p>
+          </div>
+          <span class="settings-scope-badge settings-scope-badge-server">{t("settings.scope.server")}</span>
+        </div>
+
+        <div class="settings-card-content">
+          <div class="settings-toggle-row settings-toggle-row-compact">
+            <div>
+              <div class="settings-toggle-title">{t("settings.opencode.executionProfiles.form.kind.label")}</div>
+              <div class="settings-toggle-caption">{t("settings.opencode.executionProfiles.form.kind.subtitle")}</div>
+            </div>
+            <select class="selector-input w-full max-w-xs" value={kind()} onChange={(event) => setKind(event.currentTarget.value as ExecutionProfile["kind"])}>
+              <For each={kindOptions()}>{(option) => <option value={option.value}>{option.label}</option>}</For>
+            </select>
+          </div>
+
+          <div class="settings-toggle-row settings-toggle-row-compact">
+            <div>
+              <div class="settings-toggle-title">{t("settings.opencode.executionProfiles.form.name.label")}</div>
+              <div class="settings-toggle-caption">{t("settings.opencode.executionProfiles.form.name.subtitle")}</div>
+            </div>
+            <input class="selector-input w-full max-w-xs" value={name()} placeholder={t("settings.opencode.executionProfiles.form.name.placeholder")} onInput={(event) => setName(event.currentTarget.value)} />
+          </div>
+
+          <Show when={kind() === "local" || kind() === "wsl" || kind() === "ssh"}>
+            <div class="settings-toggle-row settings-toggle-row-compact">
+              <div>
+                <div class="settings-toggle-title">{t("settings.opencode.executionProfiles.form.binaryPath.label")}</div>
+                <div class="settings-toggle-caption">{t("settings.opencode.executionProfiles.form.binaryPath.subtitle")}</div>
+              </div>
+              <input class="selector-input w-full max-w-xs" value={binaryPath()} placeholder={t("settings.opencode.executionProfiles.form.binaryPath.placeholder")} onInput={(event) => setBinaryPath(event.currentTarget.value)} />
+            </div>
+          </Show>
+
+          <Show when={kind() === "ssh"}>
+            <div class="settings-toggle-row settings-toggle-row-compact">
+              <div>
+                <div class="settings-toggle-title">{t("settings.opencode.executionProfiles.form.sshHost.label")}</div>
+                <div class="settings-toggle-caption">{t("settings.opencode.executionProfiles.form.sshHost.subtitle")}</div>
+              </div>
+              <input class="selector-input w-full max-w-xs" value={sshHost()} placeholder={t("settings.opencode.executionProfiles.form.sshHost.placeholder")} onInput={(event) => setSshHost(event.currentTarget.value)} />
+            </div>
+
+            <div class="settings-toggle-row settings-toggle-row-compact">
+              <div>
+                <div class="settings-toggle-title">{t("settings.opencode.executionProfiles.form.sshPort.label")}</div>
+                <div class="settings-toggle-caption">{t("settings.opencode.executionProfiles.form.sshPort.subtitle")}</div>
+              </div>
+              <input class="selector-input w-full max-w-xs" value={sshPort()} inputMode="numeric" placeholder={t("settings.opencode.executionProfiles.form.sshPort.placeholder")} onInput={(event) => setSshPort(event.currentTarget.value)} />
+            </div>
+
+            <div class="settings-toggle-row settings-toggle-row-compact">
+              <div>
+                <div class="settings-toggle-title">{t("settings.opencode.executionProfiles.form.sshUsername.label")}</div>
+                <div class="settings-toggle-caption">{t("settings.opencode.executionProfiles.form.sshUsername.subtitle")}</div>
+              </div>
+              <input class="selector-input w-full max-w-xs" value={sshUsername()} placeholder={t("settings.opencode.executionProfiles.form.sshUsername.placeholder")} onInput={(event) => setSshUsername(event.currentTarget.value)} />
+            </div>
+
+            <div class="settings-toggle-row settings-toggle-row-compact">
+              <div>
+                <div class="settings-toggle-title">{t("settings.opencode.executionProfiles.form.sshRemotePath.label")}</div>
+                <div class="settings-toggle-caption">{t("settings.opencode.executionProfiles.form.sshRemotePath.subtitle")}</div>
+              </div>
+              <input class="selector-input w-full max-w-xs" value={sshRemotePath()} placeholder={t("settings.opencode.executionProfiles.form.sshRemotePath.placeholder")} onInput={(event) => setSshRemotePath(event.currentTarget.value)} />
+            </div>
+
+            <div class="settings-form-group">
+              <label class="settings-form-label">{t("settings.opencode.executionProfiles.form.args.label")}</label>
+              <textarea class="selector-input w-full min-h-[6rem]" value={argsText()} placeholder={t("settings.opencode.executionProfiles.form.args.placeholder")} onInput={(event) => setArgsText(event.currentTarget.value)} />
+            </div>
+          </Show>
+
+          <Show when={kind() === "wsl"}>
+            <div class="settings-toggle-row settings-toggle-row-compact">
+              <div>
+                <div class="settings-toggle-title">{t("settings.opencode.executionProfiles.form.distro.label")}</div>
+                <div class="settings-toggle-caption">{t("settings.opencode.executionProfiles.form.distro.subtitle")}</div>
+              </div>
+              <input class="selector-input w-full max-w-xs" value={distro()} placeholder={t("settings.opencode.executionProfiles.form.distro.placeholder")} onInput={(event) => setDistro(event.currentTarget.value)} />
+            </div>
+          </Show>
+
+          <Show when={kind() === "docker"}>
+            <div class="settings-toggle-row settings-toggle-row-compact">
+              <div>
+                <div class="settings-toggle-title">{t("settings.opencode.executionProfiles.form.image.label")}</div>
+                <div class="settings-toggle-caption">{t("settings.opencode.executionProfiles.form.image.subtitle")}</div>
+              </div>
+              <input class="selector-input w-full max-w-xs" value={image()} placeholder={t("settings.opencode.executionProfiles.form.image.placeholder")} onInput={(event) => setImage(event.currentTarget.value)} />
+            </div>
+
+            <div class="settings-toggle-row settings-toggle-row-compact">
+              <div>
+                <div class="settings-toggle-title">{t("settings.opencode.executionProfiles.form.workspaceMountPath.label")}</div>
+                <div class="settings-toggle-caption">{t("settings.opencode.executionProfiles.form.workspaceMountPath.subtitle")}</div>
+              </div>
+              <input class="selector-input w-full max-w-xs" value={workspaceMountPath()} placeholder={t("settings.opencode.executionProfiles.form.workspaceMountPath.placeholder")} onInput={(event) => setWorkspaceMountPath(event.currentTarget.value)} />
+            </div>
+
+            <div class="settings-toggle-row settings-toggle-row-compact">
+              <div>
+                <div class="settings-toggle-title">{t("settings.opencode.executionProfiles.form.configMountPath.label")}</div>
+                <div class="settings-toggle-caption">{t("settings.opencode.executionProfiles.form.configMountPath.subtitle")}</div>
+              </div>
+              <input class="selector-input w-full max-w-xs" value={configMountPath()} placeholder={t("settings.opencode.executionProfiles.form.configMountPath.placeholder")} onInput={(event) => setConfigMountPath(event.currentTarget.value)} />
+            </div>
+
+            <div class="settings-form-group">
+              <label class="settings-form-label">{t("settings.opencode.executionProfiles.form.command.label")}</label>
+              <textarea class="selector-input w-full min-h-[6rem]" value={commandText()} placeholder={t("settings.opencode.executionProfiles.form.command.placeholder")} onInput={(event) => setCommandText(event.currentTarget.value)} />
+            </div>
+
+            <div class="settings-form-group">
+              <label class="settings-form-label">{t("settings.opencode.executionProfiles.form.extraDockerArgs.label")}</label>
+              <textarea class="selector-input w-full min-h-[6rem]" value={extraDockerArgsText()} placeholder={t("settings.opencode.executionProfiles.form.extraDockerArgs.placeholder")} onInput={(event) => setExtraDockerArgsText(event.currentTarget.value)} />
+            </div>
+          </Show>
+
+          <Show when={kind() === "command"}>
+            <div class="settings-toggle-row settings-toggle-row-compact">
+              <div>
+                <div class="settings-toggle-title">{t("settings.opencode.executionProfiles.form.executable.label")}</div>
+                <div class="settings-toggle-caption">{t("settings.opencode.executionProfiles.form.executable.subtitle")}</div>
+              </div>
+              <input class="selector-input w-full max-w-xs" value={executable()} placeholder={t("settings.opencode.executionProfiles.form.executable.placeholder")} onInput={(event) => setExecutable(event.currentTarget.value)} />
+            </div>
+
+            <div class="settings-toggle-row settings-toggle-row-compact">
+              <div>
+                <div class="settings-toggle-title">{t("settings.opencode.executionProfiles.form.cwdMode.label")}</div>
+                <div class="settings-toggle-caption">{t("settings.opencode.executionProfiles.form.cwdMode.subtitle")}</div>
+              </div>
+              <select class="selector-input w-full max-w-xs" value={cwdMode()} onChange={(event) => setCwdMode(event.currentTarget.value as "workspace" | "inherit") }>
+                <option value="workspace">{t("settings.opencode.executionProfiles.form.cwdMode.workspace")}</option>
+                <option value="inherit">{t("settings.opencode.executionProfiles.form.cwdMode.inherit")}</option>
+              </select>
+            </div>
+
+            <div class="settings-form-group">
+              <label class="settings-form-label">{t("settings.opencode.executionProfiles.form.args.label")}</label>
+              <textarea class="selector-input w-full min-h-[6rem]" value={argsText()} placeholder={t("settings.opencode.executionProfiles.form.args.placeholder")} onInput={(event) => setArgsText(event.currentTarget.value)} />
+            </div>
+          </Show>
+
+          <div class="settings-toggle-row settings-toggle-row-compact">
+            <div>
+              <div class="settings-toggle-title">{t("settings.opencode.executionProfiles.form.previewWorkspacePath.label")}</div>
+              <div class="settings-toggle-caption">{t("settings.opencode.executionProfiles.form.previewWorkspacePath.subtitle")}</div>
+            </div>
+            <input class="selector-input w-full max-w-xs" value={previewWorkspacePath()} placeholder={t("settings.opencode.executionProfiles.form.previewWorkspacePath.placeholder")} onInput={(event) => setPreviewWorkspacePath(event.currentTarget.value)} />
+          </div>
+
+          <Show when={formError()}>
+            <div class="settings-error-message">{formError()}</div>
+          </Show>
+
+          <Show when={previewError()}>
+            <div class="settings-error-message">{previewError()}</div>
+          </Show>
+
+          <Show when={testError()}>
+            <div class="settings-error-message">{testError()}</div>
+          </Show>
+
+          <div class="flex justify-end gap-2 mt-4">
+            <Show when={editingId()}>
+              <button type="button" class="selector-button selector-button-secondary" onClick={() => resetForm()}>
+                {t("settings.opencode.executionProfiles.form.cancelEdit")}
+              </button>
+            </Show>
+            <button type="button" class="selector-button selector-button-secondary" disabled={saving() || previewing() || testing()} onClick={() => void handleTest()}>
+              <span>{testing() ? t("settings.opencode.executionProfiles.form.testing") : t("settings.opencode.executionProfiles.form.test")}</span>
+            </button>
+            <button type="button" class="selector-button selector-button-secondary" disabled={saving() || previewing() || testing()} onClick={() => void handlePreview()}>
+              <span>{previewing() ? t("settings.opencode.executionProfiles.form.previewing") : t("settings.opencode.executionProfiles.form.preview")}</span>
+            </button>
+            <button type="button" class="selector-button selector-button-primary" disabled={saving() || previewing() || testing()} onClick={() => void handleSave()}>
+              <Show when={saving()} fallback={<Plus class="w-4 h-4" />}>
+                <Plus class="w-4 h-4" />
+              </Show>
+              <span>{editingId() ? t("settings.opencode.executionProfiles.form.update") : t("settings.opencode.executionProfiles.form.save")}</span>
+            </button>
+          </div>
+
+          <Show when={testResult()}>
+            {(result) => (
+              <div class="settings-form-group mt-4">
+                <div class="settings-form-label">{t("settings.opencode.executionProfiles.test.title")}</div>
+                <div class="mt-3 rounded-lg border border-base bg-surface-secondary p-3 text-sm text-primary">
+                  <Show when={result().valid} fallback={<span>{result().error ?? t("settings.opencode.executionProfiles.test.failureFallback")}</span>}>
+                    <span>
+                      {result().version
+                        ? t("settings.opencode.executionProfiles.test.successWithVersion", { version: result().version })
+                        : t("settings.opencode.executionProfiles.test.success")}
+                    </span>
+                  </Show>
+                </div>
+              </div>
+            )}
+          </Show>
+
+          <Show when={previewResult()}>
+            {(result) => (
+              <div class="settings-form-group mt-4">
+                <div class="settings-form-label">{t("settings.opencode.executionProfiles.preview.title")}</div>
+                <div class="settings-toggle-caption">{t("settings.opencode.executionProfiles.preview.subtitle")}</div>
+
+                <div class="mt-3 rounded-lg border border-base bg-surface-secondary p-3 flex flex-col gap-3">
+                  <div>
+                    <div class="text-xs font-medium uppercase tracking-wide text-secondary">{t("settings.opencode.executionProfiles.preview.commandLine")}</div>
+                    <pre class="mt-2 text-xs whitespace-pre-wrap break-all text-primary bg-surface-primary border border-base rounded-md p-4 font-mono">{result().commandLine}</pre>
+                  </div>
+
+                  <div>
+                    <div class="text-xs font-medium uppercase tracking-wide text-secondary">{t("settings.opencode.executionProfiles.preview.cwd")}</div>
+                    <pre class="mt-2 text-xs whitespace-pre-wrap break-all text-primary bg-surface-primary border border-base rounded-md p-4 font-mono">{result().cwd ?? t("settings.opencode.executionProfiles.preview.cwd.inherit")}</pre>
+                  </div>
+
+                  <div>
+                    <div class="text-xs font-medium uppercase tracking-wide text-secondary">{t("settings.opencode.executionProfiles.preview.environment")}</div>
+                    <pre class="mt-2 text-xs whitespace-pre-wrap break-all text-primary bg-surface-primary border border-base rounded-md p-4 font-mono">{formatPreviewEnvironment(result().environment)}</pre>
+                  </div>
+                </div>
+              </div>
+            )}
+          </Show>
+        </div>
+      </div>
+
+      <div class="settings-card">
+        <div class="settings-card-header">
+          <div>
+            <h3 class="settings-card-title">{t("settings.opencode.executionProfiles.list.title")}</h3>
+            <p class="settings-card-subtitle">{t("settings.opencode.executionProfiles.list.subtitle")}</p>
+          </div>
+        </div>
+
+        <div class="settings-card-content">
+          <Show when={executionProfiles().length > 0} fallback={<div class="settings-card-message">{t("settings.opencode.executionProfiles.list.empty")}</div>}>
+            <For each={executionProfiles()}>
+              {(profile) => {
+                const isDefault = () => defaultExecutionProfileId() === profile.id
+                return (
+                  <div class="settings-toggle-row settings-toggle-row-compact">
+                    <div>
+                      <div class="settings-toggle-title flex items-center gap-2 flex-wrap">
+                        <span>{profile.name}</span>
+                        <span class="text-xs text-muted uppercase">{t(`settings.opencode.executionProfiles.kind.${profile.kind}`)}</span>
+                        <Show when={isDefault()}>
+                          <span class="settings-scope-badge settings-scope-badge-server">{t("settings.opencode.executionProfiles.list.defaultBadge")}</span>
+                        </Show>
+                      </div>
+                      <div class="settings-toggle-caption">{buildProfileSummary(profile)}</div>
+                    </div>
+
+                    <div class="flex items-center gap-2">
+                      <button type="button" class="selector-button selector-button-secondary" onClick={() => resetForm(profile)} title={t("settings.opencode.executionProfiles.list.actions.edit")}>
+                        <Pencil class="w-4 h-4" />
+                      </button>
+                      <button type="button" class="selector-button selector-button-secondary" onClick={() => void handleDuplicate(profile)} title={t("settings.opencode.executionProfiles.list.actions.duplicate")}>
+                        <Copy class="w-4 h-4" />
+                      </button>
+                      <button type="button" class="selector-button selector-button-secondary" disabled={isDefault()} onClick={() => void setDefaultExecutionProfileId(profile.id)} title={t("settings.opencode.executionProfiles.list.actions.makeDefault")}>
+                        <Star class="w-4 h-4" />
+                      </button>
+                      <button type="button" class="selector-button selector-button-secondary" onClick={() => removeExecutionProfile(profile.id)} title={t("settings.opencode.executionProfiles.list.actions.delete")}>
+                        <Trash2 class="w-4 h-4" />
+                      </button>
+                    </div>
+                  </div>
+                )
+              }}
+            </For>
+          </Show>
+        </div>
+      </div>
+    </div>
+  )
+}
diff --git a/packages/ui/src/components/settings/opencode-settings-section.tsx b/packages/ui/src/components/settings/opencode-settings-section.tsx
index 8c0bc01b7..07a74a4bf 100644
--- a/packages/ui/src/components/settings/opencode-settings-section.tsx
+++ b/packages/ui/src/components/settings/opencode-settings-section.tsx
@@ -3,6 +3,7 @@ import { createEffect, createMemo, createSignal, type Component } from "solid-js
 import { ChevronDown, Terminal } from "lucide-solid"
 import OpenCodeBinarySelector from "../opencode-binary-selector"
 import EnvironmentVariablesEditor from "../environment-variables-editor"
+import { ExecutionProfilesSettingsSection } from "./execution-profiles-settings-section"
 import { useConfig } from "../../stores/preferences"
 import type { ServerLogLevel } from "../../stores/preferences"
 import { useI18n } from "../../lib/i18n"
@@ -53,6 +54,8 @@ export const OpenCodeSettingsSection: Component = () => {
         <OpenCodeBinarySelector selectedBinary={selectedBinary()} onBinaryChange={handleBinaryChange} isVisible />
       </div>
 
+      <ExecutionProfilesSettingsSection />
+
       <div class="settings-card">
         <div class="settings-card-header">
           <div>
diff --git a/packages/ui/src/components/tool-call.tsx b/packages/ui/src/components/tool-call.tsx
index 21f2c6085..af9be1ebd 100644
--- a/packages/ui/src/components/tool-call.tsx
+++ b/packages/ui/src/components/tool-call.tsx
@@ -1,5 +1,5 @@
 import { createSignal, Show, createEffect, createMemo, onCleanup, type Accessor } from "solid-js"
-import { ArrowRightSquare, Check, Copy, Hourglass, Loader2, XCircle } from "lucide-solid"
+import { ArrowRightSquare, Check, Copy, Hourglass, Loader2, Volume2, XCircle } from "lucide-solid"
 import { stringify as stringifyYaml } from "yaml"
 import { messageStoreBus } from "../stores/message-v2/bus"
 import { useTheme } from "../lib/theme"
@@ -45,6 +45,7 @@ import { getLogger } from "../lib/logger"
 import { useSpeech } from "../lib/hooks/use-speech"
 import SpeechActionButton from "./speech-action-button"
 import { createFollowScroll } from "../lib/follow-scroll"
+import ActionOverflowMenu, { type ActionOverflowMenuItem } from "./action-overflow-menu"
 
 const log = getLogger("session")
 
@@ -821,23 +822,62 @@ export default function ToolCall(props: ToolCallProps) {
     await copyToClipboard(text)
   }
 
+  const actionMenuItems = (): ActionOverflowMenuItem[] => {
+    const items: ActionOverflowMenuItem[] = []
+
+    if (hasToolInput()) {
+      items.push({
+        key: "toggle-input",
+        label: isToolInputVisible() ? t("toolCall.header.hideInputTitle") : t("toolCall.header.showInputTitle"),
+        icon: <ArrowRightSquare class="w-3.5 h-3.5" aria-hidden="true" />,
+        onSelect: () => {
+          if (!expanded()) toggle()
+          const currentlyVisible = isToolInputVisible()
+          setToolInputVisibilityOverride(currentlyVisible ? "hidden" : "expanded")
+        },
+      })
+    }
+
+    items.push({
+      key: "copy",
+      label: t("toolCall.header.copyTitle"),
+      icon: <Copy class="w-3.5 h-3.5" aria-hidden="true" />,
+      onSelect: async () => {
+        const text = headerText()
+        if (!text) return
+        await copyToClipboard(text)
+      },
+    })
+
+    if (canSpeakToolCall()) {
+      items.push({
+        key: "speak",
+        label: speech.buttonTitle(),
+        icon: <Volume2 class="w-3.5 h-3.5" aria-hidden="true" />,
+        onSelect: () => void speech.toggle(),
+      })
+    }
+
+    return items
+  }
+
   const status = () => toolState()?.status || ""
 
   return (
-    <div
+      <div
 
-      ref={(element) => {
+        ref={(element) => {
         setToolCallRootEl(element || undefined)
       }}
       class={`tool-call ${combinedStatusClass()}`}
       data-part-type="tool"
       data-tool-name={toolName()}
       data-instance-id={props.instanceId}
-      data-session-id={props.sessionId}
-      data-message-id={props.messageId}
-      data-part-id={toolCallIdentifier()}
-    >
-      <div class="tool-call-header">
+        data-session-id={props.sessionId}
+        data-message-id={props.messageId}
+        data-part-id={toolCallIdentifier()}
+      >
+      <div class="tool-call-header" data-action-overflow={actionMenuItems().length > 1 ? "true" : undefined}>
         <button
           type="button"
           class="tool-call-header-toggle"
@@ -886,6 +926,13 @@ export default function ToolCall(props: ToolCallProps) {
           />
         </Show>
 
+        <ActionOverflowMenu
+          items={actionMenuItems()}
+          label={t("messageItem.actions.more")}
+          triggerClass="tool-call-header-copy"
+          minItems={2}
+        />
+
         <ToolStatusIndicator status={status} />
       </div>
 
diff --git a/packages/ui/src/lib/api-client.ts b/packages/ui/src/lib/api-client.ts
index e9acec27b..ddd68d3f2 100644
--- a/packages/ui/src/lib/api-client.ts
+++ b/packages/ui/src/lib/api-client.ts
@@ -3,6 +3,9 @@ import type {
   BackgroundProcessListResponse,
   BackgroundProcessOutputResponse,
   BinaryValidationResult,
+  ExecutionProfilePreviewRequest,
+  ExecutionProfilePreviewResponse,
+  ExecutionProfileTestResponse,
   FileSystemEntry,
   FileSystemCreateFolderResponse,
   FileSystemFileContentResponse,
@@ -409,6 +412,18 @@ export const serverApi = {
       body: JSON.stringify({ path }),
     })
   },
+  previewExecutionProfile(payload: ExecutionProfilePreviewRequest): Promise<ExecutionProfilePreviewResponse> {
+    return request<ExecutionProfilePreviewResponse>("/api/storage/execution-profiles/preview", {
+      method: "POST",
+      body: JSON.stringify(payload),
+    })
+  },
+  testExecutionProfile(payload: ExecutionProfilePreviewRequest): Promise<ExecutionProfileTestResponse> {
+    return request<ExecutionProfileTestResponse>("/api/storage/execution-profiles/test", {
+      method: "POST",
+      body: JSON.stringify(payload),
+    })
+  },
   fetchSpeechCapabilities(): Promise<SpeechCapabilitiesResponse> {
     return request<SpeechCapabilitiesResponse>("/api/speech/capabilities")
   },
diff --git a/packages/ui/src/lib/i18n/messages/en/folderSelection.ts b/packages/ui/src/lib/i18n/messages/en/folderSelection.ts
index 5acb51b95..8ee809205 100644
--- a/packages/ui/src/lib/i18n/messages/en/folderSelection.ts
+++ b/packages/ui/src/lib/i18n/messages/en/folderSelection.ts
@@ -43,6 +43,8 @@ export const folderSelectionMessages = {
   "folderSelection.actions.title": "Open Folder or Connect Server",
   "folderSelection.actions.subtitle": "Open local folder or connect to a CodeNomad server",
   "folderSelection.actions.connectButton": "Connect CodeNomad Server",
+  "folderSelection.executionProfile.label": "Execution Profile",
+  "folderSelection.executionProfile.subtitle": "Choose how new local workspaces launch OpenCode",
 
   "folderSelection.advancedSettings": "Advanced Settings",
   "folderSelection.opencode": "OpenCode",
@@ -64,18 +66,21 @@ export const folderSelectionMessages = {
   "folderSelection.dialog.description": "Select workspace to start coding.",
 
   "folderSelection.tabs.local": "Local Folders",
-  "folderSelection.tabs.servers": "Servers",
-  "folderSelection.servers.title": "Saved Servers",
-  "folderSelection.servers.subtitle": "Open a saved remote CodeNomad server in a new window",
-  "folderSelection.servers.count": "{count} Servers",
-  "folderSelection.servers.empty.title": "No Saved Servers",
+  "folderSelection.tabs.servers": "Connections",
+  "folderSelection.servers.title": "Saved Connections",
+  "folderSelection.servers.subtitle": "Open a saved remote connection from this device",
+  "folderSelection.servers.count": "{count} Connections",
+  "folderSelection.servers.empty.title": "No Saved Connections",
   "folderSelection.servers.empty.description": "Add a remote server to reconnect quickly from this device",
   "folderSelection.servers.connectTitle": "Connect to Server",
   "folderSelection.servers.connectSubtitle": "Save a remote CodeNomad server and open it in a new window",
   "folderSelection.servers.connectButton": "Connect to Server",
-  "folderSelection.servers.remove": "Remove saved server",
+  "folderSelection.servers.remove": "Remove saved connection",
+  "folderSelection.servers.kind.remoteServer": "server",
+  "folderSelection.servers.lastConnected": "Last connected {time}",
   "folderSelection.servers.skipTls": "Self-signed TLS",
   "folderSelection.servers.errorTitle": "Remote Connection Failed",
+  "folderSelection.servers.errorDesktopOnly": "Remote server windows can only be opened from a local desktop window.",
   "folderSelection.servers.dialog.title": "Connect to Server",
   "folderSelection.servers.dialog.description": "Add a remote CodeNomad server and optionally open it right away.",
   "folderSelection.servers.dialog.name": "Server name",
diff --git a/packages/ui/src/lib/i18n/messages/en/instance.ts b/packages/ui/src/lib/i18n/messages/en/instance.ts
index 153adaa43..3b95e5bc7 100644
--- a/packages/ui/src/lib/i18n/messages/en/instance.ts
+++ b/packages/ui/src/lib/i18n/messages/en/instance.ts
@@ -10,6 +10,7 @@ export const instanceMessages = {
   "instanceInfo.labels.versionControl": "Version Control",
   "instanceInfo.labels.opencodeVersion": "OpenCode Version",
   "instanceInfo.labels.binaryPath": "Binary Path",
+  "instanceInfo.labels.executionProfile": "Execution Profile",
   "instanceInfo.labels.environmentVariables": "Environment Variables ({count})",
   "instanceInfo.loading": "Loading...",
   "instanceInfo.server.title": "Server",
diff --git a/packages/ui/src/lib/i18n/messages/en/messaging.ts b/packages/ui/src/lib/i18n/messages/en/messaging.ts
index 13db40dfe..63e96fe4c 100644
--- a/packages/ui/src/lib/i18n/messages/en/messaging.ts
+++ b/packages/ui/src/lib/i18n/messages/en/messaging.ts
@@ -89,6 +89,7 @@ export const messagingMessages = {
   "messageItem.actions.copy": "Copy",
   "messageItem.actions.copyTitle": "Copy message",
   "messageItem.actions.copied": "Copied!",
+  "messageItem.actions.more": "More actions",
   "messageItem.actions.speak": "Speak message",
   "messageItem.actions.generatingSpeech": "Generating speech",
   "messageItem.actions.stopSpeech": "Stop playback",
diff --git a/packages/ui/src/lib/i18n/messages/en/settings.ts b/packages/ui/src/lib/i18n/messages/en/settings.ts
index 35f3999c0..cf017147a 100644
--- a/packages/ui/src/lib/i18n/messages/en/settings.ts
+++ b/packages/ui/src/lib/i18n/messages/en/settings.ts
@@ -125,6 +125,95 @@ export const settingsMessages = {
   "settings.opencode.logLevel.option.info": "Info",
   "settings.opencode.logLevel.option.warn": "Warn",
   "settings.opencode.logLevel.option.error": "Error",
+  "settings.opencode.executionProfiles.title": "Execution Profiles",
+  "settings.opencode.executionProfiles.subtitle": "Define how CodeNomad should run OpenCode for local workspaces.",
+  "settings.opencode.executionProfiles.kind.local": "Local",
+  "settings.opencode.executionProfiles.kind.wsl": "WSL",
+  "settings.opencode.executionProfiles.kind.docker": "Docker",
+  "settings.opencode.executionProfiles.kind.command": "Command",
+  "settings.opencode.executionProfiles.kind.ssh": "SSH",
+  "settings.opencode.executionProfiles.form.kind.label": "Profile type",
+  "settings.opencode.executionProfiles.form.kind.subtitle": "Choose the runtime strategy for this profile.",
+  "settings.opencode.executionProfiles.form.name.label": "Profile name",
+  "settings.opencode.executionProfiles.form.name.subtitle": "Use a clear label you can recognise later.",
+  "settings.opencode.executionProfiles.form.name.placeholder": "Docker Sandbox",
+  "settings.opencode.executionProfiles.form.binaryPath.label": "Binary path",
+  "settings.opencode.executionProfiles.form.binaryPath.subtitle": "Absolute path to the OpenCode executable.",
+  "settings.opencode.executionProfiles.form.binaryPath.placeholder": "C:\\Tools\\opencode.exe",
+  "settings.opencode.executionProfiles.form.distro.label": "WSL distro",
+  "settings.opencode.executionProfiles.form.distro.subtitle": "Name of the WSL distribution to use.",
+  "settings.opencode.executionProfiles.form.distro.placeholder": "Ubuntu",
+  "settings.opencode.executionProfiles.form.image.label": "Docker image",
+  "settings.opencode.executionProfiles.form.image.subtitle": "Container image used to run OpenCode.",
+  "settings.opencode.executionProfiles.form.image.placeholder": "ghcr.io/example/opencode:latest",
+  "settings.opencode.executionProfiles.form.workspaceMountPath.label": "Workspace mount path",
+  "settings.opencode.executionProfiles.form.workspaceMountPath.subtitle": "Path inside the container where the workspace is mounted.",
+  "settings.opencode.executionProfiles.form.workspaceMountPath.placeholder": "/workspace",
+  "settings.opencode.executionProfiles.form.configMountPath.label": "Config mount path",
+  "settings.opencode.executionProfiles.form.configMountPath.subtitle": "Path inside the container where the OpenCode config directory is mounted.",
+  "settings.opencode.executionProfiles.form.configMountPath.placeholder": "/root/.config/opencode",
+  "settings.opencode.executionProfiles.form.command.label": "Container command",
+  "settings.opencode.executionProfiles.form.command.placeholder": "One argument per line",
+  "settings.opencode.executionProfiles.form.extraDockerArgs.label": "Extra Docker args",
+  "settings.opencode.executionProfiles.form.extraDockerArgs.placeholder": "One docker argument per line",
+  "settings.opencode.executionProfiles.form.executable.label": "Executable",
+  "settings.opencode.executionProfiles.form.executable.subtitle": "Program or script to launch for this profile.",
+  "settings.opencode.executionProfiles.form.executable.placeholder": "node",
+  "settings.opencode.executionProfiles.form.cwdMode.label": "Working directory",
+  "settings.opencode.executionProfiles.form.cwdMode.subtitle": "Choose whether the command starts in the workspace directory.",
+  "settings.opencode.executionProfiles.form.cwdMode.workspace": "Workspace folder",
+  "settings.opencode.executionProfiles.form.cwdMode.inherit": "Inherit current process cwd",
+  "settings.opencode.executionProfiles.form.args.label": "Arguments",
+  "settings.opencode.executionProfiles.form.args.placeholder": "One argument per line",
+  "settings.opencode.executionProfiles.form.sshHost.label": "SSH host",
+  "settings.opencode.executionProfiles.form.sshHost.subtitle": "Remote SSH server used to run OpenCode.",
+  "settings.opencode.executionProfiles.form.sshHost.placeholder": "vm.example.com",
+  "settings.opencode.executionProfiles.form.sshPort.label": "SSH port",
+  "settings.opencode.executionProfiles.form.sshPort.subtitle": "Port used by the remote SSH server.",
+  "settings.opencode.executionProfiles.form.sshPort.placeholder": "22",
+  "settings.opencode.executionProfiles.form.sshUsername.label": "SSH username",
+  "settings.opencode.executionProfiles.form.sshUsername.subtitle": "Optional login user for the remote host.",
+  "settings.opencode.executionProfiles.form.sshUsername.placeholder": "ubuntu",
+  "settings.opencode.executionProfiles.form.sshRemotePath.label": "Remote workspace path",
+  "settings.opencode.executionProfiles.form.sshRemotePath.subtitle": "Workspace directory on the remote SSH host.",
+  "settings.opencode.executionProfiles.form.sshRemotePath.placeholder": "/srv/project",
+  "settings.opencode.executionProfiles.form.previewWorkspacePath.label": "Preview workspace path",
+  "settings.opencode.executionProfiles.form.previewWorkspacePath.subtitle": "Optional sample workspace path used to resolve cwd and Docker mounts.",
+  "settings.opencode.executionProfiles.form.previewWorkspacePath.placeholder": "D:\\CodeNomad",
+  "settings.opencode.executionProfiles.form.test": "Test profile",
+  "settings.opencode.executionProfiles.form.testing": "Testing...",
+  "settings.opencode.executionProfiles.form.preview": "Preview command",
+  "settings.opencode.executionProfiles.form.previewing": "Previewing...",
+  "settings.opencode.executionProfiles.form.save": "Save profile",
+  "settings.opencode.executionProfiles.form.update": "Update profile",
+  "settings.opencode.executionProfiles.form.cancelEdit": "Cancel edit",
+  "settings.opencode.executionProfiles.list.title": "Saved execution profiles",
+  "settings.opencode.executionProfiles.list.subtitle": "Review and manage the execution profiles available on this server.",
+  "settings.opencode.executionProfiles.list.empty": "No execution profiles configured yet.",
+  "settings.opencode.executionProfiles.list.defaultBadge": "Default",
+  "settings.opencode.executionProfiles.list.actions.edit": "Edit profile",
+  "settings.opencode.executionProfiles.list.actions.duplicate": "Duplicate profile",
+  "settings.opencode.executionProfiles.list.actions.delete": "Delete profile",
+  "settings.opencode.executionProfiles.list.actions.makeDefault": "Set as default profile",
+  "settings.common.duplicateSuffix": "Copy",
+  "settings.opencode.executionProfiles.preview.title": "Command preview",
+  "settings.opencode.executionProfiles.preview.subtitle": "Shows the generated launcher command with current server settings. Secrets are redacted.",
+  "settings.opencode.executionProfiles.preview.commandLine": "Command line",
+  "settings.opencode.executionProfiles.preview.cwd": "Working directory",
+  "settings.opencode.executionProfiles.preview.cwd.inherit": "Inherit current process cwd",
+  "settings.opencode.executionProfiles.preview.environment": "Environment",
+  "settings.opencode.executionProfiles.test.title": "Profile test",
+  "settings.opencode.executionProfiles.test.success": "Profile check passed.",
+  "settings.opencode.executionProfiles.test.successWithVersion": "Profile check passed. Detected version: {version}",
+  "settings.opencode.executionProfiles.test.failureFallback": "Profile check failed.",
+  "settings.opencode.executionProfiles.validation.name": "Profile name is required.",
+  "settings.opencode.executionProfiles.validation.binaryPath": "Binary path is required.",
+  "settings.opencode.executionProfiles.validation.distro": "WSL distro is required.",
+  "settings.opencode.executionProfiles.validation.docker": "Docker image and mount paths are required.",
+  "settings.opencode.executionProfiles.validation.executable": "Executable is required.",
+  "settings.opencode.executionProfiles.validation.sshHost": "SSH host is required.",
+  "settings.opencode.executionProfiles.validation.sshPort": "SSH port must be between 1 and 65535.",
+  "settings.opencode.executionProfiles.validation.sshRemotePath": "Remote workspace path is required.",
 
 
   "settings.appearance.behavior.title": "Interaction",
diff --git a/packages/ui/src/lib/i18n/messages/es/folderSelection.ts b/packages/ui/src/lib/i18n/messages/es/folderSelection.ts
index 4d0367587..51169ef80 100644
--- a/packages/ui/src/lib/i18n/messages/es/folderSelection.ts
+++ b/packages/ui/src/lib/i18n/messages/es/folderSelection.ts
@@ -43,6 +43,8 @@ export const folderSelectionMessages = {
   "folderSelection.actions.title": "Abrir carpeta o conectar servidor",
   "folderSelection.actions.subtitle": "Abre una carpeta local o conéctate a un servidor de CodeNomad",
   "folderSelection.actions.connectButton": "Conectar servidor CodeNomad",
+  "folderSelection.executionProfile.label": "Perfil de ejecución",
+  "folderSelection.executionProfile.subtitle": "Elige cómo los nuevos espacios de trabajo locales inician OpenCode",
 
   "folderSelection.advancedSettings": "Configuración avanzada",
   "folderSelection.opencode": "OpenCode",
@@ -64,18 +66,21 @@ export const folderSelectionMessages = {
   "folderSelection.dialog.description": "Selecciona un workspace para empezar a programar.",
 
   "folderSelection.tabs.local": "Carpetas locales",
-  "folderSelection.tabs.servers": "Servidores",
-  "folderSelection.servers.title": "Servidores guardados",
-  "folderSelection.servers.subtitle": "Abre un servidor remoto de CodeNomad guardado en una ventana nueva",
-  "folderSelection.servers.count": "{count} servidores",
-  "folderSelection.servers.empty.title": "No hay servidores guardados",
-  "folderSelection.servers.empty.description": "Añade un servidor remoto para volver a conectarte rápidamente desde este dispositivo",
+  "folderSelection.tabs.servers": "Conexiones",
+  "folderSelection.servers.title": "Conexiones guardadas",
+  "folderSelection.servers.subtitle": "Abre una conexión remota guardada desde este dispositivo",
+  "folderSelection.servers.count": "{count} conexiones",
+  "folderSelection.servers.empty.title": "No hay conexiones guardadas",
+  "folderSelection.servers.empty.description": "Añade un servidor remoto para reconectarte rápidamente desde este dispositivo",
   "folderSelection.servers.connectTitle": "Conectar a un servidor",
   "folderSelection.servers.connectSubtitle": "Guarda un servidor remoto de CodeNomad y ábrelo en una ventana nueva",
   "folderSelection.servers.connectButton": "Conectar a un servidor",
-  "folderSelection.servers.remove": "Eliminar servidor guardado",
+  "folderSelection.servers.remove": "Eliminar conexión guardada",
+  "folderSelection.servers.kind.remoteServer": "servidor",
+  "folderSelection.servers.lastConnected": "Última conexión {time}",
   "folderSelection.servers.skipTls": "TLS autofirmado",
   "folderSelection.servers.errorTitle": "Falló la conexión remota",
+  "folderSelection.servers.errorDesktopOnly": "Las ventanas de servidor remoto solo se pueden abrir desde una ventana local de escritorio.",
   "folderSelection.servers.dialog.title": "Conectar a un servidor",
   "folderSelection.servers.dialog.description": "Añade un servidor remoto de CodeNomad y ábrelo ahora si quieres.",
   "folderSelection.servers.dialog.name": "Nombre del servidor",
diff --git a/packages/ui/src/lib/i18n/messages/es/instance.ts b/packages/ui/src/lib/i18n/messages/es/instance.ts
index f01aa8de1..f30623920 100644
--- a/packages/ui/src/lib/i18n/messages/es/instance.ts
+++ b/packages/ui/src/lib/i18n/messages/es/instance.ts
@@ -10,6 +10,7 @@ export const instanceMessages = {
   "instanceInfo.labels.versionControl": "Control de versiones",
   "instanceInfo.labels.opencodeVersion": "Versión de OpenCode",
   "instanceInfo.labels.binaryPath": "Ruta del binario",
+  "instanceInfo.labels.executionProfile": "Perfil de ejecucion",
   "instanceInfo.labels.environmentVariables": "Variables de entorno ({count})",
   "instanceInfo.loading": "Cargando...",
   "instanceInfo.server.title": "Servidor",
diff --git a/packages/ui/src/lib/i18n/messages/es/messaging.ts b/packages/ui/src/lib/i18n/messages/es/messaging.ts
index 95ae39243..496f1da91 100644
--- a/packages/ui/src/lib/i18n/messages/es/messaging.ts
+++ b/packages/ui/src/lib/i18n/messages/es/messaging.ts
@@ -91,6 +91,7 @@ export const messagingMessages = {
   "messageItem.actions.copy": "Copiar",
   "messageItem.actions.copyTitle": "Copiar mensaje",
   "messageItem.actions.copied": "¡Copiado!",
+  "messageItem.actions.more": "Más acciones",
   "messageItem.actions.speak": "Reproducir mensaje",
   "messageItem.actions.generatingSpeech": "Generando audio",
   "messageItem.actions.stopSpeech": "Detener reproduccion",
diff --git a/packages/ui/src/lib/i18n/messages/es/settings.ts b/packages/ui/src/lib/i18n/messages/es/settings.ts
index a158ec511..74f04151b 100644
--- a/packages/ui/src/lib/i18n/messages/es/settings.ts
+++ b/packages/ui/src/lib/i18n/messages/es/settings.ts
@@ -125,6 +125,95 @@ export const settingsMessages = {
   "settings.opencode.logLevel.option.info": "Informacion",
   "settings.opencode.logLevel.option.warn": "Advertencia",
   "settings.opencode.logLevel.option.error": "Error",
+  "settings.opencode.executionProfiles.title": "Execution Profiles",
+  "settings.opencode.executionProfiles.subtitle": "Define how CodeNomad should run OpenCode for local workspaces.",
+  "settings.opencode.executionProfiles.kind.local": "Local",
+  "settings.opencode.executionProfiles.kind.wsl": "WSL",
+  "settings.opencode.executionProfiles.kind.docker": "Docker",
+  "settings.opencode.executionProfiles.kind.command": "Command",
+  "settings.opencode.executionProfiles.kind.ssh": "SSH",
+  "settings.opencode.executionProfiles.form.kind.label": "Profile type",
+  "settings.opencode.executionProfiles.form.kind.subtitle": "Choose the runtime strategy for this profile.",
+  "settings.opencode.executionProfiles.form.name.label": "Profile name",
+  "settings.opencode.executionProfiles.form.name.subtitle": "Use a clear label you can recognise later.",
+  "settings.opencode.executionProfiles.form.name.placeholder": "Docker Sandbox",
+  "settings.opencode.executionProfiles.form.binaryPath.label": "Binary path",
+  "settings.opencode.executionProfiles.form.binaryPath.subtitle": "Absolute path to the OpenCode executable.",
+  "settings.opencode.executionProfiles.form.binaryPath.placeholder": "C:\\Tools\\opencode.exe",
+  "settings.opencode.executionProfiles.form.distro.label": "WSL distro",
+  "settings.opencode.executionProfiles.form.distro.subtitle": "Name of the WSL distribution to use.",
+  "settings.opencode.executionProfiles.form.distro.placeholder": "Ubuntu",
+  "settings.opencode.executionProfiles.form.image.label": "Docker image",
+  "settings.opencode.executionProfiles.form.image.subtitle": "Container image used to run OpenCode.",
+  "settings.opencode.executionProfiles.form.image.placeholder": "ghcr.io/example/opencode:latest",
+  "settings.opencode.executionProfiles.form.workspaceMountPath.label": "Workspace mount path",
+  "settings.opencode.executionProfiles.form.workspaceMountPath.subtitle": "Path inside the container where the workspace is mounted.",
+  "settings.opencode.executionProfiles.form.workspaceMountPath.placeholder": "/workspace",
+  "settings.opencode.executionProfiles.form.configMountPath.label": "Config mount path",
+  "settings.opencode.executionProfiles.form.configMountPath.subtitle": "Path inside the container where the OpenCode config directory is mounted.",
+  "settings.opencode.executionProfiles.form.configMountPath.placeholder": "/root/.config/opencode",
+  "settings.opencode.executionProfiles.form.command.label": "Container command",
+  "settings.opencode.executionProfiles.form.command.placeholder": "One argument per line",
+  "settings.opencode.executionProfiles.form.extraDockerArgs.label": "Extra Docker args",
+  "settings.opencode.executionProfiles.form.extraDockerArgs.placeholder": "One docker argument per line",
+  "settings.opencode.executionProfiles.form.executable.label": "Executable",
+  "settings.opencode.executionProfiles.form.executable.subtitle": "Program or script to launch for this profile.",
+  "settings.opencode.executionProfiles.form.executable.placeholder": "ssh",
+  "settings.opencode.executionProfiles.form.cwdMode.label": "Working directory",
+  "settings.opencode.executionProfiles.form.cwdMode.subtitle": "Choose whether the command starts in the workspace directory.",
+  "settings.opencode.executionProfiles.form.cwdMode.workspace": "Workspace folder",
+  "settings.opencode.executionProfiles.form.cwdMode.inherit": "Inherit current process cwd",
+  "settings.opencode.executionProfiles.form.args.label": "Arguments",
+  "settings.opencode.executionProfiles.form.args.placeholder": "One argument per line",
+  "settings.opencode.executionProfiles.form.sshHost.label": "SSH host",
+  "settings.opencode.executionProfiles.form.sshHost.subtitle": "Remote SSH server used to run OpenCode.",
+  "settings.opencode.executionProfiles.form.sshHost.placeholder": "vm.example.com",
+  "settings.opencode.executionProfiles.form.sshPort.label": "SSH port",
+  "settings.opencode.executionProfiles.form.sshPort.subtitle": "Port used by the remote SSH server.",
+  "settings.opencode.executionProfiles.form.sshPort.placeholder": "22",
+  "settings.opencode.executionProfiles.form.sshUsername.label": "SSH username",
+  "settings.opencode.executionProfiles.form.sshUsername.subtitle": "Optional login user for the remote host.",
+  "settings.opencode.executionProfiles.form.sshUsername.placeholder": "ubuntu",
+  "settings.opencode.executionProfiles.form.sshRemotePath.label": "Remote workspace path",
+  "settings.opencode.executionProfiles.form.sshRemotePath.subtitle": "Workspace directory on the remote SSH host.",
+  "settings.opencode.executionProfiles.form.sshRemotePath.placeholder": "/srv/project",
+  "settings.opencode.executionProfiles.form.previewWorkspacePath.label": "Preview workspace path",
+  "settings.opencode.executionProfiles.form.previewWorkspacePath.subtitle": "Optional sample workspace path used to resolve cwd and Docker mounts.",
+  "settings.opencode.executionProfiles.form.previewWorkspacePath.placeholder": "D:\\CodeNomad",
+  "settings.opencode.executionProfiles.form.test": "Test profile",
+  "settings.opencode.executionProfiles.form.testing": "Testing...",
+  "settings.opencode.executionProfiles.form.preview": "Preview command",
+  "settings.opencode.executionProfiles.form.previewing": "Previewing...",
+  "settings.opencode.executionProfiles.form.save": "Save profile",
+  "settings.opencode.executionProfiles.form.update": "Update profile",
+  "settings.opencode.executionProfiles.form.cancelEdit": "Cancel edit",
+  "settings.opencode.executionProfiles.list.title": "Saved execution profiles",
+  "settings.opencode.executionProfiles.list.subtitle": "Review and manage the execution profiles available on this server.",
+  "settings.opencode.executionProfiles.list.empty": "No execution profiles configured yet.",
+  "settings.opencode.executionProfiles.list.defaultBadge": "Default",
+  "settings.opencode.executionProfiles.list.actions.edit": "Edit profile",
+  "settings.opencode.executionProfiles.list.actions.duplicate": "Duplicate profile",
+  "settings.opencode.executionProfiles.list.actions.delete": "Delete profile",
+  "settings.opencode.executionProfiles.list.actions.makeDefault": "Set as default profile",
+  "settings.common.duplicateSuffix": "Copy",
+  "settings.opencode.executionProfiles.preview.title": "Command preview",
+  "settings.opencode.executionProfiles.preview.subtitle": "Shows the generated launcher command with current server settings. Secrets are redacted.",
+  "settings.opencode.executionProfiles.preview.commandLine": "Command line",
+  "settings.opencode.executionProfiles.preview.cwd": "Working directory",
+  "settings.opencode.executionProfiles.preview.cwd.inherit": "Inherit current process cwd",
+  "settings.opencode.executionProfiles.preview.environment": "Environment",
+  "settings.opencode.executionProfiles.test.title": "Profile test",
+  "settings.opencode.executionProfiles.test.success": "Profile check passed.",
+  "settings.opencode.executionProfiles.test.successWithVersion": "Profile check passed. Detected version: {version}",
+  "settings.opencode.executionProfiles.test.failureFallback": "Profile check failed.",
+  "settings.opencode.executionProfiles.validation.name": "Profile name is required.",
+  "settings.opencode.executionProfiles.validation.binaryPath": "Binary path is required.",
+  "settings.opencode.executionProfiles.validation.distro": "WSL distro is required.",
+  "settings.opencode.executionProfiles.validation.docker": "Docker image and mount paths are required.",
+  "settings.opencode.executionProfiles.validation.executable": "Executable is required.",
+  "settings.opencode.executionProfiles.validation.sshHost": "SSH host is required.",
+  "settings.opencode.executionProfiles.validation.sshPort": "SSH port must be between 1 and 65535.",
+  "settings.opencode.executionProfiles.validation.sshRemotePath": "Remote workspace path is required.",
 
   "settings.appearance.behavior.title": "Interaccion",
   "settings.appearance.behavior.subtitle": "Valores predeterminados de mensajes, diffs y entrada.",
diff --git a/packages/ui/src/lib/i18n/messages/fr/folderSelection.ts b/packages/ui/src/lib/i18n/messages/fr/folderSelection.ts
index 07c132085..08d83de05 100644
--- a/packages/ui/src/lib/i18n/messages/fr/folderSelection.ts
+++ b/packages/ui/src/lib/i18n/messages/fr/folderSelection.ts
@@ -43,6 +43,8 @@ export const folderSelectionMessages = {
   "folderSelection.actions.title": "Ouvrir un dossier ou se connecter à un serveur",
   "folderSelection.actions.subtitle": "Ouvrez un dossier local ou connectez-vous à un serveur CodeNomad",
   "folderSelection.actions.connectButton": "Se connecter au serveur CodeNomad",
+  "folderSelection.executionProfile.label": "Profil d'exécution",
+  "folderSelection.executionProfile.subtitle": "Choisissez comment les nouveaux espaces de travail locaux lancent OpenCode",
 
   "folderSelection.advancedSettings": "Paramètres avancés",
   "folderSelection.opencode": "OpenCode",
@@ -64,18 +66,21 @@ export const folderSelectionMessages = {
   "folderSelection.dialog.description": "Sélectionnez un espace de travail pour commencer à coder.",
 
   "folderSelection.tabs.local": "Dossiers locaux",
-  "folderSelection.tabs.servers": "Serveurs",
-  "folderSelection.servers.title": "Serveurs enregistrés",
-  "folderSelection.servers.subtitle": "Ouvrez un serveur CodeNomad distant enregistré dans une nouvelle fenêtre",
-  "folderSelection.servers.count": "{count} serveurs",
-  "folderSelection.servers.empty.title": "Aucun serveur enregistré",
+  "folderSelection.tabs.servers": "Connexions",
+  "folderSelection.servers.title": "Connexions enregistrées",
+  "folderSelection.servers.subtitle": "Ouvrez une connexion distante enregistrée depuis cet appareil",
+  "folderSelection.servers.count": "{count} connexions",
+  "folderSelection.servers.empty.title": "Aucune connexion enregistrée",
   "folderSelection.servers.empty.description": "Ajoutez un serveur distant pour vous reconnecter rapidement depuis cet appareil",
   "folderSelection.servers.connectTitle": "Se connecter à un serveur",
   "folderSelection.servers.connectSubtitle": "Enregistrez un serveur CodeNomad distant et ouvrez-le dans une nouvelle fenêtre",
   "folderSelection.servers.connectButton": "Se connecter à un serveur",
-  "folderSelection.servers.remove": "Supprimer le serveur enregistré",
+  "folderSelection.servers.remove": "Supprimer la connexion enregistrée",
+  "folderSelection.servers.kind.remoteServer": "serveur",
+  "folderSelection.servers.lastConnected": "Dernière connexion {time}",
   "folderSelection.servers.skipTls": "TLS auto-signé",
   "folderSelection.servers.errorTitle": "Échec de la connexion distante",
+  "folderSelection.servers.errorDesktopOnly": "Les fenêtres de serveur distant ne peuvent être ouvertes que depuis une fenêtre de bureau locale.",
   "folderSelection.servers.dialog.title": "Se connecter à un serveur",
   "folderSelection.servers.dialog.description": "Ajoutez un serveur CodeNomad distant et ouvrez-le immédiatement si vous le souhaitez.",
   "folderSelection.servers.dialog.name": "Nom du serveur",
diff --git a/packages/ui/src/lib/i18n/messages/fr/instance.ts b/packages/ui/src/lib/i18n/messages/fr/instance.ts
index 1f6efba1f..a1cd8b7bd 100644
--- a/packages/ui/src/lib/i18n/messages/fr/instance.ts
+++ b/packages/ui/src/lib/i18n/messages/fr/instance.ts
@@ -10,6 +10,7 @@ export const instanceMessages = {
   "instanceInfo.labels.versionControl": "Contrôle de version",
   "instanceInfo.labels.opencodeVersion": "Version d'OpenCode",
   "instanceInfo.labels.binaryPath": "Chemin du binaire",
+  "instanceInfo.labels.executionProfile": "Profil d'execution",
   "instanceInfo.labels.environmentVariables": "Variables d'environnement ({count})",
   "instanceInfo.loading": "Chargement...",
   "instanceInfo.server.title": "Serveur",
diff --git a/packages/ui/src/lib/i18n/messages/fr/messaging.ts b/packages/ui/src/lib/i18n/messages/fr/messaging.ts
index 5400f2619..42dd878b9 100644
--- a/packages/ui/src/lib/i18n/messages/fr/messaging.ts
+++ b/packages/ui/src/lib/i18n/messages/fr/messaging.ts
@@ -91,6 +91,7 @@ export const messagingMessages = {
   "messageItem.actions.copy": "Copier",
   "messageItem.actions.copyTitle": "Copier le message",
   "messageItem.actions.copied": "Copié !",
+  "messageItem.actions.more": "Plus d'actions",
   "messageItem.actions.speak": "Lire le message",
   "messageItem.actions.generatingSpeech": "Generation de l'audio",
   "messageItem.actions.stopSpeech": "Arreter la lecture",
diff --git a/packages/ui/src/lib/i18n/messages/fr/settings.ts b/packages/ui/src/lib/i18n/messages/fr/settings.ts
index 722292878..3d1e41388 100644
--- a/packages/ui/src/lib/i18n/messages/fr/settings.ts
+++ b/packages/ui/src/lib/i18n/messages/fr/settings.ts
@@ -125,6 +125,95 @@ export const settingsMessages = {
   "settings.opencode.logLevel.option.info": "Info",
   "settings.opencode.logLevel.option.warn": "Avertissement",
   "settings.opencode.logLevel.option.error": "Erreur",
+  "settings.opencode.executionProfiles.title": "Execution Profiles",
+  "settings.opencode.executionProfiles.subtitle": "Define how CodeNomad should run OpenCode for local workspaces.",
+  "settings.opencode.executionProfiles.kind.local": "Local",
+  "settings.opencode.executionProfiles.kind.wsl": "WSL",
+  "settings.opencode.executionProfiles.kind.docker": "Docker",
+  "settings.opencode.executionProfiles.kind.command": "Command",
+  "settings.opencode.executionProfiles.kind.ssh": "SSH",
+  "settings.opencode.executionProfiles.form.kind.label": "Profile type",
+  "settings.opencode.executionProfiles.form.kind.subtitle": "Choose the runtime strategy for this profile.",
+  "settings.opencode.executionProfiles.form.name.label": "Profile name",
+  "settings.opencode.executionProfiles.form.name.subtitle": "Use a clear label you can recognise later.",
+  "settings.opencode.executionProfiles.form.name.placeholder": "Docker Sandbox",
+  "settings.opencode.executionProfiles.form.binaryPath.label": "Binary path",
+  "settings.opencode.executionProfiles.form.binaryPath.subtitle": "Absolute path to the OpenCode executable.",
+  "settings.opencode.executionProfiles.form.binaryPath.placeholder": "C:\\Tools\\opencode.exe",
+  "settings.opencode.executionProfiles.form.distro.label": "WSL distro",
+  "settings.opencode.executionProfiles.form.distro.subtitle": "Name of the WSL distribution to use.",
+  "settings.opencode.executionProfiles.form.distro.placeholder": "Ubuntu",
+  "settings.opencode.executionProfiles.form.image.label": "Docker image",
+  "settings.opencode.executionProfiles.form.image.subtitle": "Container image used to run OpenCode.",
+  "settings.opencode.executionProfiles.form.image.placeholder": "ghcr.io/example/opencode:latest",
+  "settings.opencode.executionProfiles.form.workspaceMountPath.label": "Workspace mount path",
+  "settings.opencode.executionProfiles.form.workspaceMountPath.subtitle": "Path inside the container where the workspace is mounted.",
+  "settings.opencode.executionProfiles.form.workspaceMountPath.placeholder": "/workspace",
+  "settings.opencode.executionProfiles.form.configMountPath.label": "Config mount path",
+  "settings.opencode.executionProfiles.form.configMountPath.subtitle": "Path inside the container where the OpenCode config directory is mounted.",
+  "settings.opencode.executionProfiles.form.configMountPath.placeholder": "/root/.config/opencode",
+  "settings.opencode.executionProfiles.form.command.label": "Container command",
+  "settings.opencode.executionProfiles.form.command.placeholder": "One argument per line",
+  "settings.opencode.executionProfiles.form.extraDockerArgs.label": "Extra Docker args",
+  "settings.opencode.executionProfiles.form.extraDockerArgs.placeholder": "One docker argument per line",
+  "settings.opencode.executionProfiles.form.executable.label": "Executable",
+  "settings.opencode.executionProfiles.form.executable.subtitle": "Program or script to launch for this profile.",
+  "settings.opencode.executionProfiles.form.executable.placeholder": "ssh",
+  "settings.opencode.executionProfiles.form.cwdMode.label": "Working directory",
+  "settings.opencode.executionProfiles.form.cwdMode.subtitle": "Choose whether the command starts in the workspace directory.",
+  "settings.opencode.executionProfiles.form.cwdMode.workspace": "Workspace folder",
+  "settings.opencode.executionProfiles.form.cwdMode.inherit": "Inherit current process cwd",
+  "settings.opencode.executionProfiles.form.args.label": "Arguments",
+  "settings.opencode.executionProfiles.form.args.placeholder": "One argument per line",
+  "settings.opencode.executionProfiles.form.sshHost.label": "SSH host",
+  "settings.opencode.executionProfiles.form.sshHost.subtitle": "Remote SSH server used to run OpenCode.",
+  "settings.opencode.executionProfiles.form.sshHost.placeholder": "vm.example.com",
+  "settings.opencode.executionProfiles.form.sshPort.label": "SSH port",
+  "settings.opencode.executionProfiles.form.sshPort.subtitle": "Port used by the remote SSH server.",
+  "settings.opencode.executionProfiles.form.sshPort.placeholder": "22",
+  "settings.opencode.executionProfiles.form.sshUsername.label": "SSH username",
+  "settings.opencode.executionProfiles.form.sshUsername.subtitle": "Optional login user for the remote host.",
+  "settings.opencode.executionProfiles.form.sshUsername.placeholder": "ubuntu",
+  "settings.opencode.executionProfiles.form.sshRemotePath.label": "Remote workspace path",
+  "settings.opencode.executionProfiles.form.sshRemotePath.subtitle": "Workspace directory on the remote SSH host.",
+  "settings.opencode.executionProfiles.form.sshRemotePath.placeholder": "/srv/project",
+  "settings.opencode.executionProfiles.form.previewWorkspacePath.label": "Preview workspace path",
+  "settings.opencode.executionProfiles.form.previewWorkspacePath.subtitle": "Optional sample workspace path used to resolve cwd and Docker mounts.",
+  "settings.opencode.executionProfiles.form.previewWorkspacePath.placeholder": "D:\\CodeNomad",
+  "settings.opencode.executionProfiles.form.test": "Test profile",
+  "settings.opencode.executionProfiles.form.testing": "Testing...",
+  "settings.opencode.executionProfiles.form.preview": "Preview command",
+  "settings.opencode.executionProfiles.form.previewing": "Previewing...",
+  "settings.opencode.executionProfiles.form.save": "Save profile",
+  "settings.opencode.executionProfiles.form.update": "Update profile",
+  "settings.opencode.executionProfiles.form.cancelEdit": "Cancel edit",
+  "settings.opencode.executionProfiles.list.title": "Saved execution profiles",
+  "settings.opencode.executionProfiles.list.subtitle": "Review and manage the execution profiles available on this server.",
+  "settings.opencode.executionProfiles.list.empty": "No execution profiles configured yet.",
+  "settings.opencode.executionProfiles.list.defaultBadge": "Default",
+  "settings.opencode.executionProfiles.list.actions.edit": "Edit profile",
+  "settings.opencode.executionProfiles.list.actions.duplicate": "Duplicate profile",
+  "settings.opencode.executionProfiles.list.actions.delete": "Delete profile",
+  "settings.opencode.executionProfiles.list.actions.makeDefault": "Set as default profile",
+  "settings.common.duplicateSuffix": "Copy",
+  "settings.opencode.executionProfiles.preview.title": "Command preview",
+  "settings.opencode.executionProfiles.preview.subtitle": "Shows the generated launcher command with current server settings. Secrets are redacted.",
+  "settings.opencode.executionProfiles.preview.commandLine": "Command line",
+  "settings.opencode.executionProfiles.preview.cwd": "Working directory",
+  "settings.opencode.executionProfiles.preview.cwd.inherit": "Inherit current process cwd",
+  "settings.opencode.executionProfiles.preview.environment": "Environment",
+  "settings.opencode.executionProfiles.test.title": "Profile test",
+  "settings.opencode.executionProfiles.test.success": "Profile check passed.",
+  "settings.opencode.executionProfiles.test.successWithVersion": "Profile check passed. Detected version: {version}",
+  "settings.opencode.executionProfiles.test.failureFallback": "Profile check failed.",
+  "settings.opencode.executionProfiles.validation.name": "Profile name is required.",
+  "settings.opencode.executionProfiles.validation.binaryPath": "Binary path is required.",
+  "settings.opencode.executionProfiles.validation.distro": "WSL distro is required.",
+  "settings.opencode.executionProfiles.validation.docker": "Docker image and mount paths are required.",
+  "settings.opencode.executionProfiles.validation.executable": "Executable is required.",
+  "settings.opencode.executionProfiles.validation.sshHost": "SSH host is required.",
+  "settings.opencode.executionProfiles.validation.sshPort": "SSH port must be between 1 and 65535.",
+  "settings.opencode.executionProfiles.validation.sshRemotePath": "Remote workspace path is required.",
 
   "settings.appearance.behavior.title": "Interaction",
   "settings.appearance.behavior.subtitle": "Parametres par defaut pour les messages, les diffs et la saisie.",
diff --git a/packages/ui/src/lib/i18n/messages/he/folderSelection.ts b/packages/ui/src/lib/i18n/messages/he/folderSelection.ts
index 73910ee95..5c9571291 100644
--- a/packages/ui/src/lib/i18n/messages/he/folderSelection.ts
+++ b/packages/ui/src/lib/i18n/messages/he/folderSelection.ts
@@ -43,6 +43,8 @@ export const folderSelectionMessages = {
   "folderSelection.actions.title": "פתח תיקייה או התחבר לשרת",
   "folderSelection.actions.subtitle": "פתח תיקייה מקומית או התחבר לשרת CodeNomad",
   "folderSelection.actions.connectButton": "התחבר לשרת CodeNomad",
+  "folderSelection.executionProfile.label": "פרופיל הרצה",
+  "folderSelection.executionProfile.subtitle": "בחר איך להפעיל את OpenCode עבור סביבות עבודה מקומיות חדשות",
 
   "folderSelection.advancedSettings": "הגדרות מתקדמות",
   "folderSelection.opencode": "OpenCode",
@@ -64,18 +66,21 @@ export const folderSelectionMessages = {
   "folderSelection.dialog.description": "בחר סביבת עבודה כדי להתחיל לתכנת.",
 
   "folderSelection.tabs.local": "תיקיות מקומיות",
-  "folderSelection.tabs.servers": "שרתים",
-  "folderSelection.servers.title": "שרתים שמורים",
-  "folderSelection.servers.subtitle": "פתח שרת CodeNomad מרוחק שמור בחלון חדש",
-  "folderSelection.servers.count": "{count} שרתים",
-  "folderSelection.servers.empty.title": "אין שרתים שמורים",
+  "folderSelection.tabs.servers": "חיבורים",
+  "folderSelection.servers.title": "חיבורים שמורים",
+  "folderSelection.servers.subtitle": "פתח חיבור מרוחק שמור מהמכשיר הזה",
+  "folderSelection.servers.count": "{count} חיבורים",
+  "folderSelection.servers.empty.title": "אין חיבורים שמורים",
   "folderSelection.servers.empty.description": "הוסף שרת מרוחק כדי להתחבר אליו במהירות מהמכשיר הזה",
   "folderSelection.servers.connectTitle": "התחבר לשרת",
   "folderSelection.servers.connectSubtitle": "שמור שרת CodeNomad מרוחק ופתח אותו בחלון חדש",
   "folderSelection.servers.connectButton": "התחבר לשרת",
-  "folderSelection.servers.remove": "הסר שרת שמור",
+  "folderSelection.servers.remove": "הסר חיבור שמור",
+  "folderSelection.servers.kind.remoteServer": "שרת",
+  "folderSelection.servers.lastConnected": "חיבור אחרון {time}",
   "folderSelection.servers.skipTls": "TLS בחתימה עצמית",
   "folderSelection.servers.errorTitle": "החיבור המרוחק נכשל",
+  "folderSelection.servers.errorDesktopOnly": "ניתן לפתוח חלונות שרת מרוחק רק מחלון שולחן עבודה מקומי.",
   "folderSelection.servers.dialog.title": "התחבר לשרת",
   "folderSelection.servers.dialog.description": "הוסף שרת CodeNomad מרוחק ופתח אותו מיד אם תרצה.",
   "folderSelection.servers.dialog.name": "שם השרת",
diff --git a/packages/ui/src/lib/i18n/messages/he/instance.ts b/packages/ui/src/lib/i18n/messages/he/instance.ts
index 0897383fb..f07524f5d 100644
--- a/packages/ui/src/lib/i18n/messages/he/instance.ts
+++ b/packages/ui/src/lib/i18n/messages/he/instance.ts
@@ -10,6 +10,7 @@ export const instanceMessages = {
   "instanceInfo.labels.versionControl": "בקרת גרסאות",
   "instanceInfo.labels.opencodeVersion": "גרסת OpenCode",
   "instanceInfo.labels.binaryPath": "נתיב קובץ בינארי",
+  "instanceInfo.labels.executionProfile": "פרופיל הרצה",
   "instanceInfo.labels.environmentVariables": "משתני סביבה ({count})",
   "instanceInfo.loading": "טוען...",
   "instanceInfo.server.title": "שרת",
diff --git a/packages/ui/src/lib/i18n/messages/he/messaging.ts b/packages/ui/src/lib/i18n/messages/he/messaging.ts
index 7c24ef2eb..98e2d6e7a 100644
--- a/packages/ui/src/lib/i18n/messages/he/messaging.ts
+++ b/packages/ui/src/lib/i18n/messages/he/messaging.ts
@@ -89,6 +89,7 @@ export const messagingMessages = {
   "messageItem.actions.copy": "העתק",
   "messageItem.actions.copyTitle": "העתק הודעה",
   "messageItem.actions.copied": "הועתק!",
+  "messageItem.actions.more": "פעולות נוספות",
   "messageItem.actions.speak": "השמע הודעה",
   "messageItem.actions.generatingSpeech": "יוצר אודיו",
   "messageItem.actions.stopSpeech": "עצור ניגון",
diff --git a/packages/ui/src/lib/i18n/messages/he/settings.ts b/packages/ui/src/lib/i18n/messages/he/settings.ts
index cc8b59044..59f509e43 100644
--- a/packages/ui/src/lib/i18n/messages/he/settings.ts
+++ b/packages/ui/src/lib/i18n/messages/he/settings.ts
@@ -124,6 +124,95 @@ export const settingsMessages = {
   "settings.opencode.logLevel.option.info": "מידע",
   "settings.opencode.logLevel.option.warn": "אזהרה",
   "settings.opencode.logLevel.option.error": "שגיאה",
+  "settings.opencode.executionProfiles.title": "Execution Profiles",
+  "settings.opencode.executionProfiles.subtitle": "Define how CodeNomad should run OpenCode for local workspaces.",
+  "settings.opencode.executionProfiles.kind.local": "Local",
+  "settings.opencode.executionProfiles.kind.wsl": "WSL",
+  "settings.opencode.executionProfiles.kind.docker": "Docker",
+  "settings.opencode.executionProfiles.kind.command": "Command",
+  "settings.opencode.executionProfiles.kind.ssh": "SSH",
+  "settings.opencode.executionProfiles.form.kind.label": "Profile type",
+  "settings.opencode.executionProfiles.form.kind.subtitle": "Choose the runtime strategy for this profile.",
+  "settings.opencode.executionProfiles.form.name.label": "Profile name",
+  "settings.opencode.executionProfiles.form.name.subtitle": "Use a clear label you can recognise later.",
+  "settings.opencode.executionProfiles.form.name.placeholder": "Docker Sandbox",
+  "settings.opencode.executionProfiles.form.binaryPath.label": "Binary path",
+  "settings.opencode.executionProfiles.form.binaryPath.subtitle": "Absolute path to the OpenCode executable.",
+  "settings.opencode.executionProfiles.form.binaryPath.placeholder": "C:\\Tools\\opencode.exe",
+  "settings.opencode.executionProfiles.form.distro.label": "WSL distro",
+  "settings.opencode.executionProfiles.form.distro.subtitle": "Name of the WSL distribution to use.",
+  "settings.opencode.executionProfiles.form.distro.placeholder": "Ubuntu",
+  "settings.opencode.executionProfiles.form.image.label": "Docker image",
+  "settings.opencode.executionProfiles.form.image.subtitle": "Container image used to run OpenCode.",
+  "settings.opencode.executionProfiles.form.image.placeholder": "ghcr.io/example/opencode:latest",
+  "settings.opencode.executionProfiles.form.workspaceMountPath.label": "Workspace mount path",
+  "settings.opencode.executionProfiles.form.workspaceMountPath.subtitle": "Path inside the container where the workspace is mounted.",
+  "settings.opencode.executionProfiles.form.workspaceMountPath.placeholder": "/workspace",
+  "settings.opencode.executionProfiles.form.configMountPath.label": "Config mount path",
+  "settings.opencode.executionProfiles.form.configMountPath.subtitle": "Path inside the container where the OpenCode config directory is mounted.",
+  "settings.opencode.executionProfiles.form.configMountPath.placeholder": "/root/.config/opencode",
+  "settings.opencode.executionProfiles.form.command.label": "Container command",
+  "settings.opencode.executionProfiles.form.command.placeholder": "One argument per line",
+  "settings.opencode.executionProfiles.form.extraDockerArgs.label": "Extra Docker args",
+  "settings.opencode.executionProfiles.form.extraDockerArgs.placeholder": "One docker argument per line",
+  "settings.opencode.executionProfiles.form.executable.label": "Executable",
+  "settings.opencode.executionProfiles.form.executable.subtitle": "Program or script to launch for this profile.",
+  "settings.opencode.executionProfiles.form.executable.placeholder": "ssh",
+  "settings.opencode.executionProfiles.form.cwdMode.label": "Working directory",
+  "settings.opencode.executionProfiles.form.cwdMode.subtitle": "Choose whether the command starts in the workspace directory.",
+  "settings.opencode.executionProfiles.form.cwdMode.workspace": "Workspace folder",
+  "settings.opencode.executionProfiles.form.cwdMode.inherit": "Inherit current process cwd",
+  "settings.opencode.executionProfiles.form.args.label": "Arguments",
+  "settings.opencode.executionProfiles.form.args.placeholder": "One argument per line",
+  "settings.opencode.executionProfiles.form.sshHost.label": "SSH host",
+  "settings.opencode.executionProfiles.form.sshHost.subtitle": "Remote SSH server used to run OpenCode.",
+  "settings.opencode.executionProfiles.form.sshHost.placeholder": "vm.example.com",
+  "settings.opencode.executionProfiles.form.sshPort.label": "SSH port",
+  "settings.opencode.executionProfiles.form.sshPort.subtitle": "Port used by the remote SSH server.",
+  "settings.opencode.executionProfiles.form.sshPort.placeholder": "22",
+  "settings.opencode.executionProfiles.form.sshUsername.label": "SSH username",
+  "settings.opencode.executionProfiles.form.sshUsername.subtitle": "Optional login user for the remote host.",
+  "settings.opencode.executionProfiles.form.sshUsername.placeholder": "ubuntu",
+  "settings.opencode.executionProfiles.form.sshRemotePath.label": "Remote workspace path",
+  "settings.opencode.executionProfiles.form.sshRemotePath.subtitle": "Workspace directory on the remote SSH host.",
+  "settings.opencode.executionProfiles.form.sshRemotePath.placeholder": "/srv/project",
+  "settings.opencode.executionProfiles.form.previewWorkspacePath.label": "Preview workspace path",
+  "settings.opencode.executionProfiles.form.previewWorkspacePath.subtitle": "Optional sample workspace path used to resolve cwd and Docker mounts.",
+  "settings.opencode.executionProfiles.form.previewWorkspacePath.placeholder": "D:\\CodeNomad",
+  "settings.opencode.executionProfiles.form.test": "Test profile",
+  "settings.opencode.executionProfiles.form.testing": "Testing...",
+  "settings.opencode.executionProfiles.form.preview": "Preview command",
+  "settings.opencode.executionProfiles.form.previewing": "Previewing...",
+  "settings.opencode.executionProfiles.form.save": "Save profile",
+  "settings.opencode.executionProfiles.form.update": "Update profile",
+  "settings.opencode.executionProfiles.form.cancelEdit": "Cancel edit",
+  "settings.opencode.executionProfiles.list.title": "Saved execution profiles",
+  "settings.opencode.executionProfiles.list.subtitle": "Review and manage the execution profiles available on this server.",
+  "settings.opencode.executionProfiles.list.empty": "No execution profiles configured yet.",
+  "settings.opencode.executionProfiles.list.defaultBadge": "Default",
+  "settings.opencode.executionProfiles.list.actions.edit": "Edit profile",
+  "settings.opencode.executionProfiles.list.actions.duplicate": "Duplicate profile",
+  "settings.opencode.executionProfiles.list.actions.delete": "Delete profile",
+  "settings.opencode.executionProfiles.list.actions.makeDefault": "Set as default profile",
+  "settings.common.duplicateSuffix": "Copy",
+  "settings.opencode.executionProfiles.preview.title": "Command preview",
+  "settings.opencode.executionProfiles.preview.subtitle": "Shows the generated launcher command with current server settings. Secrets are redacted.",
+  "settings.opencode.executionProfiles.preview.commandLine": "Command line",
+  "settings.opencode.executionProfiles.preview.cwd": "Working directory",
+  "settings.opencode.executionProfiles.preview.cwd.inherit": "Inherit current process cwd",
+  "settings.opencode.executionProfiles.preview.environment": "Environment",
+  "settings.opencode.executionProfiles.test.title": "Profile test",
+  "settings.opencode.executionProfiles.test.success": "Profile check passed.",
+  "settings.opencode.executionProfiles.test.successWithVersion": "Profile check passed. Detected version: {version}",
+  "settings.opencode.executionProfiles.test.failureFallback": "Profile check failed.",
+  "settings.opencode.executionProfiles.validation.name": "Profile name is required.",
+  "settings.opencode.executionProfiles.validation.binaryPath": "Binary path is required.",
+  "settings.opencode.executionProfiles.validation.distro": "WSL distro is required.",
+  "settings.opencode.executionProfiles.validation.docker": "Docker image and mount paths are required.",
+  "settings.opencode.executionProfiles.validation.executable": "Executable is required.",
+  "settings.opencode.executionProfiles.validation.sshHost": "SSH host is required.",
+  "settings.opencode.executionProfiles.validation.sshPort": "SSH port must be between 1 and 65535.",
+  "settings.opencode.executionProfiles.validation.sshRemotePath": "Remote workspace path is required.",
 
   "settings.appearance.behavior.title": "אינטראקציה",
   "settings.appearance.behavior.subtitle": "ברירות מחדל להודעות, diff וקלט.",
diff --git a/packages/ui/src/lib/i18n/messages/ja/folderSelection.ts b/packages/ui/src/lib/i18n/messages/ja/folderSelection.ts
index b114a71e0..2fa7b17b4 100644
--- a/packages/ui/src/lib/i18n/messages/ja/folderSelection.ts
+++ b/packages/ui/src/lib/i18n/messages/ja/folderSelection.ts
@@ -43,6 +43,8 @@ export const folderSelectionMessages = {
   "folderSelection.actions.title": "フォルダを開くかサーバーに接続",
   "folderSelection.actions.subtitle": "ローカルフォルダを開くか CodeNomad サーバーに接続します",
   "folderSelection.actions.connectButton": "CodeNomad サーバーに接続",
+  "folderSelection.executionProfile.label": "実行プロファイル",
+  "folderSelection.executionProfile.subtitle": "新しいローカルワークスペースで OpenCode をどう起動するか選択します",
 
   "folderSelection.advancedSettings": "詳細設定",
   "folderSelection.opencode": "OpenCode",
@@ -64,18 +66,21 @@ export const folderSelectionMessages = {
   "folderSelection.dialog.description": "コーディングを開始するワークスペースを選択してください。",
 
   "folderSelection.tabs.local": "ローカルフォルダ",
-  "folderSelection.tabs.servers": "サーバー",
-  "folderSelection.servers.title": "保存済みサーバー",
-  "folderSelection.servers.subtitle": "保存したリモート CodeNomad サーバーを新しいウィンドウで開きます",
-  "folderSelection.servers.count": "{count} サーバー",
-  "folderSelection.servers.empty.title": "保存済みサーバーはありません",
+  "folderSelection.tabs.servers": "接続",
+  "folderSelection.servers.title": "保存済み接続",
+  "folderSelection.servers.subtitle": "この端末から保存済みのリモート接続を開きます",
+  "folderSelection.servers.count": "{count} 接続",
+  "folderSelection.servers.empty.title": "保存済み接続はありません",
   "folderSelection.servers.empty.description": "この端末からすばやく再接続できるように、リモートサーバーを追加してください",
   "folderSelection.servers.connectTitle": "サーバーに接続",
   "folderSelection.servers.connectSubtitle": "リモート CodeNomad サーバーを保存して新しいウィンドウで開きます",
   "folderSelection.servers.connectButton": "サーバーに接続",
-  "folderSelection.servers.remove": "保存したサーバーを削除",
+  "folderSelection.servers.remove": "保存した接続を削除",
+  "folderSelection.servers.kind.remoteServer": "サーバー",
+  "folderSelection.servers.lastConnected": "最終接続 {time}",
   "folderSelection.servers.skipTls": "自己署名 TLS",
   "folderSelection.servers.errorTitle": "リモート接続に失敗しました",
+  "folderSelection.servers.errorDesktopOnly": "リモートサーバーウィンドウはローカルデスクトップウィンドウからのみ開けます。",
   "folderSelection.servers.dialog.title": "サーバーに接続",
   "folderSelection.servers.dialog.description": "リモート CodeNomad サーバーを追加し、必要に応じてすぐに開きます。",
   "folderSelection.servers.dialog.name": "サーバー名",
diff --git a/packages/ui/src/lib/i18n/messages/ja/instance.ts b/packages/ui/src/lib/i18n/messages/ja/instance.ts
index ca6cd5511..b3e16b37c 100644
--- a/packages/ui/src/lib/i18n/messages/ja/instance.ts
+++ b/packages/ui/src/lib/i18n/messages/ja/instance.ts
@@ -10,6 +10,7 @@ export const instanceMessages = {
   "instanceInfo.labels.versionControl": "バージョン管理",
   "instanceInfo.labels.opencodeVersion": "OpenCode バージョン",
   "instanceInfo.labels.binaryPath": "バイナリのパス",
+  "instanceInfo.labels.executionProfile": "実行プロファイル",
   "instanceInfo.labels.environmentVariables": "環境変数 ({count})",
   "instanceInfo.loading": "読み込み中...",
   "instanceInfo.server.title": "サーバー",
diff --git a/packages/ui/src/lib/i18n/messages/ja/messaging.ts b/packages/ui/src/lib/i18n/messages/ja/messaging.ts
index 42b866ba8..39c1da8a3 100644
--- a/packages/ui/src/lib/i18n/messages/ja/messaging.ts
+++ b/packages/ui/src/lib/i18n/messages/ja/messaging.ts
@@ -91,6 +91,7 @@ export const messagingMessages = {
   "messageItem.actions.copy": "コピー",
   "messageItem.actions.copyTitle": "メッセージをコピー",
   "messageItem.actions.copied": "コピーしました!",
+  "messageItem.actions.more": "その他の操作",
   "messageItem.actions.speak": "メッセージを読み上げ",
   "messageItem.actions.generatingSpeech": "音声を生成中",
   "messageItem.actions.stopSpeech": "再生を停止",
diff --git a/packages/ui/src/lib/i18n/messages/ja/settings.ts b/packages/ui/src/lib/i18n/messages/ja/settings.ts
index f764acbfc..bc71dfda2 100644
--- a/packages/ui/src/lib/i18n/messages/ja/settings.ts
+++ b/packages/ui/src/lib/i18n/messages/ja/settings.ts
@@ -125,6 +125,95 @@ export const settingsMessages = {
   "settings.opencode.logLevel.option.info": "情報",
   "settings.opencode.logLevel.option.warn": "警告",
   "settings.opencode.logLevel.option.error": "エラー",
+  "settings.opencode.executionProfiles.title": "Execution Profiles",
+  "settings.opencode.executionProfiles.subtitle": "Define how CodeNomad should run OpenCode for local workspaces.",
+  "settings.opencode.executionProfiles.kind.local": "Local",
+  "settings.opencode.executionProfiles.kind.wsl": "WSL",
+  "settings.opencode.executionProfiles.kind.docker": "Docker",
+  "settings.opencode.executionProfiles.kind.command": "Command",
+  "settings.opencode.executionProfiles.kind.ssh": "SSH",
+  "settings.opencode.executionProfiles.form.kind.label": "Profile type",
+  "settings.opencode.executionProfiles.form.kind.subtitle": "Choose the runtime strategy for this profile.",
+  "settings.opencode.executionProfiles.form.name.label": "Profile name",
+  "settings.opencode.executionProfiles.form.name.subtitle": "Use a clear label you can recognise later.",
+  "settings.opencode.executionProfiles.form.name.placeholder": "Docker Sandbox",
+  "settings.opencode.executionProfiles.form.binaryPath.label": "Binary path",
+  "settings.opencode.executionProfiles.form.binaryPath.subtitle": "Absolute path to the OpenCode executable.",
+  "settings.opencode.executionProfiles.form.binaryPath.placeholder": "C:\\Tools\\opencode.exe",
+  "settings.opencode.executionProfiles.form.distro.label": "WSL distro",
+  "settings.opencode.executionProfiles.form.distro.subtitle": "Name of the WSL distribution to use.",
+  "settings.opencode.executionProfiles.form.distro.placeholder": "Ubuntu",
+  "settings.opencode.executionProfiles.form.image.label": "Docker image",
+  "settings.opencode.executionProfiles.form.image.subtitle": "Container image used to run OpenCode.",
+  "settings.opencode.executionProfiles.form.image.placeholder": "ghcr.io/example/opencode:latest",
+  "settings.opencode.executionProfiles.form.workspaceMountPath.label": "Workspace mount path",
+  "settings.opencode.executionProfiles.form.workspaceMountPath.subtitle": "Path inside the container where the workspace is mounted.",
+  "settings.opencode.executionProfiles.form.workspaceMountPath.placeholder": "/workspace",
+  "settings.opencode.executionProfiles.form.configMountPath.label": "Config mount path",
+  "settings.opencode.executionProfiles.form.configMountPath.subtitle": "Path inside the container where the OpenCode config directory is mounted.",
+  "settings.opencode.executionProfiles.form.configMountPath.placeholder": "/root/.config/opencode",
+  "settings.opencode.executionProfiles.form.command.label": "Container command",
+  "settings.opencode.executionProfiles.form.command.placeholder": "One argument per line",
+  "settings.opencode.executionProfiles.form.extraDockerArgs.label": "Extra Docker args",
+  "settings.opencode.executionProfiles.form.extraDockerArgs.placeholder": "One docker argument per line",
+  "settings.opencode.executionProfiles.form.executable.label": "Executable",
+  "settings.opencode.executionProfiles.form.executable.subtitle": "Program or script to launch for this profile.",
+  "settings.opencode.executionProfiles.form.executable.placeholder": "ssh",
+  "settings.opencode.executionProfiles.form.cwdMode.label": "Working directory",
+  "settings.opencode.executionProfiles.form.cwdMode.subtitle": "Choose whether the command starts in the workspace directory.",
+  "settings.opencode.executionProfiles.form.cwdMode.workspace": "Workspace folder",
+  "settings.opencode.executionProfiles.form.cwdMode.inherit": "Inherit current process cwd",
+  "settings.opencode.executionProfiles.form.args.label": "Arguments",
+  "settings.opencode.executionProfiles.form.args.placeholder": "One argument per line",
+  "settings.opencode.executionProfiles.form.sshHost.label": "SSH host",
+  "settings.opencode.executionProfiles.form.sshHost.subtitle": "Remote SSH server used to run OpenCode.",
+  "settings.opencode.executionProfiles.form.sshHost.placeholder": "vm.example.com",
+  "settings.opencode.executionProfiles.form.sshPort.label": "SSH port",
+  "settings.opencode.executionProfiles.form.sshPort.subtitle": "Port used by the remote SSH server.",
+  "settings.opencode.executionProfiles.form.sshPort.placeholder": "22",
+  "settings.opencode.executionProfiles.form.sshUsername.label": "SSH username",
+  "settings.opencode.executionProfiles.form.sshUsername.subtitle": "Optional login user for the remote host.",
+  "settings.opencode.executionProfiles.form.sshUsername.placeholder": "ubuntu",
+  "settings.opencode.executionProfiles.form.sshRemotePath.label": "Remote workspace path",
+  "settings.opencode.executionProfiles.form.sshRemotePath.subtitle": "Workspace directory on the remote SSH host.",
+  "settings.opencode.executionProfiles.form.sshRemotePath.placeholder": "/srv/project",
+  "settings.opencode.executionProfiles.form.previewWorkspacePath.label": "Preview workspace path",
+  "settings.opencode.executionProfiles.form.previewWorkspacePath.subtitle": "Optional sample workspace path used to resolve cwd and Docker mounts.",
+  "settings.opencode.executionProfiles.form.previewWorkspacePath.placeholder": "D:\\CodeNomad",
+  "settings.opencode.executionProfiles.form.test": "Test profile",
+  "settings.opencode.executionProfiles.form.testing": "Testing...",
+  "settings.opencode.executionProfiles.form.preview": "Preview command",
+  "settings.opencode.executionProfiles.form.previewing": "Previewing...",
+  "settings.opencode.executionProfiles.form.save": "Save profile",
+  "settings.opencode.executionProfiles.form.update": "Update profile",
+  "settings.opencode.executionProfiles.form.cancelEdit": "Cancel edit",
+  "settings.opencode.executionProfiles.list.title": "Saved execution profiles",
+  "settings.opencode.executionProfiles.list.subtitle": "Review and manage the execution profiles available on this server.",
+  "settings.opencode.executionProfiles.list.empty": "No execution profiles configured yet.",
+  "settings.opencode.executionProfiles.list.defaultBadge": "Default",
+  "settings.opencode.executionProfiles.list.actions.edit": "Edit profile",
+  "settings.opencode.executionProfiles.list.actions.duplicate": "Duplicate profile",
+  "settings.opencode.executionProfiles.list.actions.delete": "Delete profile",
+  "settings.opencode.executionProfiles.list.actions.makeDefault": "Set as default profile",
+  "settings.common.duplicateSuffix": "Copy",
+  "settings.opencode.executionProfiles.preview.title": "Command preview",
+  "settings.opencode.executionProfiles.preview.subtitle": "Shows the generated launcher command with current server settings. Secrets are redacted.",
+  "settings.opencode.executionProfiles.preview.commandLine": "Command line",
+  "settings.opencode.executionProfiles.preview.cwd": "Working directory",
+  "settings.opencode.executionProfiles.preview.cwd.inherit": "Inherit current process cwd",
+  "settings.opencode.executionProfiles.preview.environment": "Environment",
+  "settings.opencode.executionProfiles.test.title": "Profile test",
+  "settings.opencode.executionProfiles.test.success": "Profile check passed.",
+  "settings.opencode.executionProfiles.test.successWithVersion": "Profile check passed. Detected version: {version}",
+  "settings.opencode.executionProfiles.test.failureFallback": "Profile check failed.",
+  "settings.opencode.executionProfiles.validation.name": "Profile name is required.",
+  "settings.opencode.executionProfiles.validation.binaryPath": "Binary path is required.",
+  "settings.opencode.executionProfiles.validation.distro": "WSL distro is required.",
+  "settings.opencode.executionProfiles.validation.docker": "Docker image and mount paths are required.",
+  "settings.opencode.executionProfiles.validation.executable": "Executable is required.",
+  "settings.opencode.executionProfiles.validation.sshHost": "SSH host is required.",
+  "settings.opencode.executionProfiles.validation.sshPort": "SSH port must be between 1 and 65535.",
+  "settings.opencode.executionProfiles.validation.sshRemotePath": "Remote workspace path is required.",
 
   "settings.appearance.behavior.title": "操作",
   "settings.appearance.behavior.subtitle": "メッセージ、差分、入力の既定値。",
diff --git a/packages/ui/src/lib/i18n/messages/ru/folderSelection.ts b/packages/ui/src/lib/i18n/messages/ru/folderSelection.ts
index 851b947d5..897c33316 100644
--- a/packages/ui/src/lib/i18n/messages/ru/folderSelection.ts
+++ b/packages/ui/src/lib/i18n/messages/ru/folderSelection.ts
@@ -43,6 +43,8 @@ export const folderSelectionMessages = {
   "folderSelection.actions.title": "Открыть папку или подключить сервер",
   "folderSelection.actions.subtitle": "Откройте локальную папку или подключитесь к серверу CodeNomad",
   "folderSelection.actions.connectButton": "Подключить сервер CodeNomad",
+  "folderSelection.executionProfile.label": "Профиль выполнения",
+  "folderSelection.executionProfile.subtitle": "Выберите, как OpenCode должен запускаться для новых локальных рабочих пространств",
 
   "folderSelection.advancedSettings": "Расширенные настройки",
   "folderSelection.opencode": "OpenCode",
@@ -64,18 +66,21 @@ export const folderSelectionMessages = {
   "folderSelection.dialog.description": "Выберите рабочее пространство, чтобы начать писать код.",
 
   "folderSelection.tabs.local": "Локальные папки",
-  "folderSelection.tabs.servers": "Серверы",
-  "folderSelection.servers.title": "Сохраненные серверы",
-  "folderSelection.servers.subtitle": "Откройте сохраненный удаленный сервер CodeNomad в новом окне",
-  "folderSelection.servers.count": "{count} серверов",
-  "folderSelection.servers.empty.title": "Нет сохраненных серверов",
+  "folderSelection.tabs.servers": "Подключения",
+  "folderSelection.servers.title": "Сохраненные подключения",
+  "folderSelection.servers.subtitle": "Откройте сохраненное удаленное подключение с этого устройства",
+  "folderSelection.servers.count": "{count} подключений",
+  "folderSelection.servers.empty.title": "Нет сохраненных подключений",
   "folderSelection.servers.empty.description": "Добавьте удаленный сервер, чтобы быстро подключаться к нему с этого устройства",
   "folderSelection.servers.connectTitle": "Подключиться к серверу",
   "folderSelection.servers.connectSubtitle": "Сохраните удаленный сервер CodeNomad и откройте его в новом окне",
   "folderSelection.servers.connectButton": "Подключиться к серверу",
-  "folderSelection.servers.remove": "Удалить сохраненный сервер",
+  "folderSelection.servers.remove": "Удалить сохраненное подключение",
+  "folderSelection.servers.kind.remoteServer": "сервер",
+  "folderSelection.servers.lastConnected": "Последнее подключение {time}",
   "folderSelection.servers.skipTls": "Самоподписанный TLS",
   "folderSelection.servers.errorTitle": "Ошибка удаленного подключения",
+  "folderSelection.servers.errorDesktopOnly": "Окна удаленного сервера можно открывать только из локального настольного окна.",
   "folderSelection.servers.dialog.title": "Подключиться к серверу",
   "folderSelection.servers.dialog.description": "Добавьте удаленный сервер CodeNomad и при желании сразу откройте его.",
   "folderSelection.servers.dialog.name": "Имя сервера",
diff --git a/packages/ui/src/lib/i18n/messages/ru/instance.ts b/packages/ui/src/lib/i18n/messages/ru/instance.ts
index bce93442d..b9177831a 100644
--- a/packages/ui/src/lib/i18n/messages/ru/instance.ts
+++ b/packages/ui/src/lib/i18n/messages/ru/instance.ts
@@ -10,6 +10,7 @@ export const instanceMessages = {
   "instanceInfo.labels.versionControl": "Система контроля версий",
   "instanceInfo.labels.opencodeVersion": "Версия OpenCode",
   "instanceInfo.labels.binaryPath": "Путь к бинарнику",
+  "instanceInfo.labels.executionProfile": "Профиль выполнения",
   "instanceInfo.labels.environmentVariables": "Переменные окружения ({count})",
   "instanceInfo.loading": "Загрузка…",
   "instanceInfo.server.title": "Сервер",
diff --git a/packages/ui/src/lib/i18n/messages/ru/messaging.ts b/packages/ui/src/lib/i18n/messages/ru/messaging.ts
index 2e5981525..c22eb7f9d 100644
--- a/packages/ui/src/lib/i18n/messages/ru/messaging.ts
+++ b/packages/ui/src/lib/i18n/messages/ru/messaging.ts
@@ -91,6 +91,7 @@ export const messagingMessages = {
   "messageItem.actions.copy": "Копировать",
   "messageItem.actions.copyTitle": "Копировать сообщение",
   "messageItem.actions.copied": "Скопировано!",
+  "messageItem.actions.more": "Больше действий",
   "messageItem.actions.speak": "Озвучить сообщение",
   "messageItem.actions.generatingSpeech": "Генерация аудио",
   "messageItem.actions.stopSpeech": "Остановить воспроизведение",
diff --git a/packages/ui/src/lib/i18n/messages/ru/settings.ts b/packages/ui/src/lib/i18n/messages/ru/settings.ts
index 2b9dc2f2b..8a72fcc9b 100644
--- a/packages/ui/src/lib/i18n/messages/ru/settings.ts
+++ b/packages/ui/src/lib/i18n/messages/ru/settings.ts
@@ -125,6 +125,95 @@ export const settingsMessages = {
   "settings.opencode.logLevel.option.info": "Информация",
   "settings.opencode.logLevel.option.warn": "Предупреждение",
   "settings.opencode.logLevel.option.error": "Ошибка",
+  "settings.opencode.executionProfiles.title": "Execution Profiles",
+  "settings.opencode.executionProfiles.subtitle": "Define how CodeNomad should run OpenCode for local workspaces.",
+  "settings.opencode.executionProfiles.kind.local": "Local",
+  "settings.opencode.executionProfiles.kind.wsl": "WSL",
+  "settings.opencode.executionProfiles.kind.docker": "Docker",
+  "settings.opencode.executionProfiles.kind.command": "Command",
+  "settings.opencode.executionProfiles.kind.ssh": "SSH",
+  "settings.opencode.executionProfiles.form.kind.label": "Profile type",
+  "settings.opencode.executionProfiles.form.kind.subtitle": "Choose the runtime strategy for this profile.",
+  "settings.opencode.executionProfiles.form.name.label": "Profile name",
+  "settings.opencode.executionProfiles.form.name.subtitle": "Use a clear label you can recognise later.",
+  "settings.opencode.executionProfiles.form.name.placeholder": "Docker Sandbox",
+  "settings.opencode.executionProfiles.form.binaryPath.label": "Binary path",
+  "settings.opencode.executionProfiles.form.binaryPath.subtitle": "Absolute path to the OpenCode executable.",
+  "settings.opencode.executionProfiles.form.binaryPath.placeholder": "C:\\Tools\\opencode.exe",
+  "settings.opencode.executionProfiles.form.distro.label": "WSL distro",
+  "settings.opencode.executionProfiles.form.distro.subtitle": "Name of the WSL distribution to use.",
+  "settings.opencode.executionProfiles.form.distro.placeholder": "Ubuntu",
+  "settings.opencode.executionProfiles.form.image.label": "Docker image",
+  "settings.opencode.executionProfiles.form.image.subtitle": "Container image used to run OpenCode.",
+  "settings.opencode.executionProfiles.form.image.placeholder": "ghcr.io/example/opencode:latest",
+  "settings.opencode.executionProfiles.form.workspaceMountPath.label": "Workspace mount path",
+  "settings.opencode.executionProfiles.form.workspaceMountPath.subtitle": "Path inside the container where the workspace is mounted.",
+  "settings.opencode.executionProfiles.form.workspaceMountPath.placeholder": "/workspace",
+  "settings.opencode.executionProfiles.form.configMountPath.label": "Config mount path",
+  "settings.opencode.executionProfiles.form.configMountPath.subtitle": "Path inside the container where the OpenCode config directory is mounted.",
+  "settings.opencode.executionProfiles.form.configMountPath.placeholder": "/root/.config/opencode",
+  "settings.opencode.executionProfiles.form.command.label": "Container command",
+  "settings.opencode.executionProfiles.form.command.placeholder": "One argument per line",
+  "settings.opencode.executionProfiles.form.extraDockerArgs.label": "Extra Docker args",
+  "settings.opencode.executionProfiles.form.extraDockerArgs.placeholder": "One docker argument per line",
+  "settings.opencode.executionProfiles.form.executable.label": "Executable",
+  "settings.opencode.executionProfiles.form.executable.subtitle": "Program or script to launch for this profile.",
+  "settings.opencode.executionProfiles.form.executable.placeholder": "ssh",
+  "settings.opencode.executionProfiles.form.cwdMode.label": "Working directory",
+  "settings.opencode.executionProfiles.form.cwdMode.subtitle": "Choose whether the command starts in the workspace directory.",
+  "settings.opencode.executionProfiles.form.cwdMode.workspace": "Workspace folder",
+  "settings.opencode.executionProfiles.form.cwdMode.inherit": "Inherit current process cwd",
+  "settings.opencode.executionProfiles.form.args.label": "Arguments",
+  "settings.opencode.executionProfiles.form.args.placeholder": "One argument per line",
+  "settings.opencode.executionProfiles.form.sshHost.label": "SSH host",
+  "settings.opencode.executionProfiles.form.sshHost.subtitle": "Remote SSH server used to run OpenCode.",
+  "settings.opencode.executionProfiles.form.sshHost.placeholder": "vm.example.com",
+  "settings.opencode.executionProfiles.form.sshPort.label": "SSH port",
+  "settings.opencode.executionProfiles.form.sshPort.subtitle": "Port used by the remote SSH server.",
+  "settings.opencode.executionProfiles.form.sshPort.placeholder": "22",
+  "settings.opencode.executionProfiles.form.sshUsername.label": "SSH username",
+  "settings.opencode.executionProfiles.form.sshUsername.subtitle": "Optional login user for the remote host.",
+  "settings.opencode.executionProfiles.form.sshUsername.placeholder": "ubuntu",
+  "settings.opencode.executionProfiles.form.sshRemotePath.label": "Remote workspace path",
+  "settings.opencode.executionProfiles.form.sshRemotePath.subtitle": "Workspace directory on the remote SSH host.",
+  "settings.opencode.executionProfiles.form.sshRemotePath.placeholder": "/srv/project",
+  "settings.opencode.executionProfiles.form.previewWorkspacePath.label": "Preview workspace path",
+  "settings.opencode.executionProfiles.form.previewWorkspacePath.subtitle": "Optional sample workspace path used to resolve cwd and Docker mounts.",
+  "settings.opencode.executionProfiles.form.previewWorkspacePath.placeholder": "D:\\CodeNomad",
+  "settings.opencode.executionProfiles.form.test": "Test profile",
+  "settings.opencode.executionProfiles.form.testing": "Testing...",
+  "settings.opencode.executionProfiles.form.preview": "Preview command",
+  "settings.opencode.executionProfiles.form.previewing": "Previewing...",
+  "settings.opencode.executionProfiles.form.save": "Save profile",
+  "settings.opencode.executionProfiles.form.update": "Update profile",
+  "settings.opencode.executionProfiles.form.cancelEdit": "Cancel edit",
+  "settings.opencode.executionProfiles.list.title": "Saved execution profiles",
+  "settings.opencode.executionProfiles.list.subtitle": "Review and manage the execution profiles available on this server.",
+  "settings.opencode.executionProfiles.list.empty": "No execution profiles configured yet.",
+  "settings.opencode.executionProfiles.list.defaultBadge": "Default",
+  "settings.opencode.executionProfiles.list.actions.edit": "Edit profile",
+  "settings.opencode.executionProfiles.list.actions.duplicate": "Duplicate profile",
+  "settings.opencode.executionProfiles.list.actions.delete": "Delete profile",
+  "settings.opencode.executionProfiles.list.actions.makeDefault": "Set as default profile",
+  "settings.common.duplicateSuffix": "Copy",
+  "settings.opencode.executionProfiles.preview.title": "Command preview",
+  "settings.opencode.executionProfiles.preview.subtitle": "Shows the generated launcher command with current server settings. Secrets are redacted.",
+  "settings.opencode.executionProfiles.preview.commandLine": "Command line",
+  "settings.opencode.executionProfiles.preview.cwd": "Working directory",
+  "settings.opencode.executionProfiles.preview.cwd.inherit": "Inherit current process cwd",
+  "settings.opencode.executionProfiles.preview.environment": "Environment",
+  "settings.opencode.executionProfiles.test.title": "Profile test",
+  "settings.opencode.executionProfiles.test.success": "Profile check passed.",
+  "settings.opencode.executionProfiles.test.successWithVersion": "Profile check passed. Detected version: {version}",
+  "settings.opencode.executionProfiles.test.failureFallback": "Profile check failed.",
+  "settings.opencode.executionProfiles.validation.name": "Profile name is required.",
+  "settings.opencode.executionProfiles.validation.binaryPath": "Binary path is required.",
+  "settings.opencode.executionProfiles.validation.distro": "WSL distro is required.",
+  "settings.opencode.executionProfiles.validation.docker": "Docker image and mount paths are required.",
+  "settings.opencode.executionProfiles.validation.executable": "Executable is required.",
+  "settings.opencode.executionProfiles.validation.sshHost": "SSH host is required.",
+  "settings.opencode.executionProfiles.validation.sshPort": "SSH port must be between 1 and 65535.",
+  "settings.opencode.executionProfiles.validation.sshRemotePath": "Remote workspace path is required.",
 
   "settings.appearance.behavior.title": "Взаимодействие",
   "settings.appearance.behavior.subtitle": "Значения по умолчанию для сообщений, диффов и ввода.",
diff --git a/packages/ui/src/lib/i18n/messages/zh-Hans/folderSelection.ts b/packages/ui/src/lib/i18n/messages/zh-Hans/folderSelection.ts
index 32ff05e71..270e42a0c 100644
--- a/packages/ui/src/lib/i18n/messages/zh-Hans/folderSelection.ts
+++ b/packages/ui/src/lib/i18n/messages/zh-Hans/folderSelection.ts
@@ -43,6 +43,8 @@ export const folderSelectionMessages = {
   "folderSelection.actions.title": "打开文件夹或连接服务器",
   "folderSelection.actions.subtitle": "打开本地文件夹或连接到 CodeNomad 服务器",
   "folderSelection.actions.connectButton": "连接 CodeNomad 服务器",
+  "folderSelection.executionProfile.label": "执行配置",
+  "folderSelection.executionProfile.subtitle": "选择新本地工作区启动 OpenCode 的方式",
 
   "folderSelection.advancedSettings": "高级设置",
   "folderSelection.opencode": "OpenCode",
@@ -64,18 +66,21 @@ export const folderSelectionMessages = {
   "folderSelection.dialog.description": "选择工作区以开始编码。",
 
   "folderSelection.tabs.local": "本地文件夹",
-  "folderSelection.tabs.servers": "服务器",
-  "folderSelection.servers.title": "已保存的服务器",
-  "folderSelection.servers.subtitle": "在新窗口中打开已保存的远程 CodeNomad 服务器",
-  "folderSelection.servers.count": "{count} 个服务器",
-  "folderSelection.servers.empty.title": "没有已保存的服务器",
+  "folderSelection.tabs.servers": "连接",
+  "folderSelection.servers.title": "已保存连接",
+  "folderSelection.servers.subtitle": "从此设备打开已保存的远程连接",
+  "folderSelection.servers.count": "{count} 个连接",
+  "folderSelection.servers.empty.title": "没有已保存连接",
   "folderSelection.servers.empty.description": "添加远程服务器，以便在此设备上快速重新连接",
   "folderSelection.servers.connectTitle": "连接到服务器",
   "folderSelection.servers.connectSubtitle": "保存远程 CodeNomad 服务器并在新窗口中打开它",
   "folderSelection.servers.connectButton": "连接到服务器",
-  "folderSelection.servers.remove": "删除已保存服务器",
+  "folderSelection.servers.remove": "删除已保存连接",
+  "folderSelection.servers.kind.remoteServer": "服务器",
+  "folderSelection.servers.lastConnected": "上次连接 {time}",
   "folderSelection.servers.skipTls": "自签名 TLS",
   "folderSelection.servers.errorTitle": "远程连接失败",
+  "folderSelection.servers.errorDesktopOnly": "只能从本地桌面窗口打开远程服务器窗口。",
   "folderSelection.servers.dialog.title": "连接到服务器",
   "folderSelection.servers.dialog.description": "添加远程 CodeNomad 服务器，并可选择立即打开。",
   "folderSelection.servers.dialog.name": "服务器名称",
diff --git a/packages/ui/src/lib/i18n/messages/zh-Hans/instance.ts b/packages/ui/src/lib/i18n/messages/zh-Hans/instance.ts
index 70a378c9b..8a87f0997 100644
--- a/packages/ui/src/lib/i18n/messages/zh-Hans/instance.ts
+++ b/packages/ui/src/lib/i18n/messages/zh-Hans/instance.ts
@@ -10,6 +10,7 @@ export const instanceMessages = {
   "instanceInfo.labels.versionControl": "版本控制",
   "instanceInfo.labels.opencodeVersion": "OpenCode 版本",
   "instanceInfo.labels.binaryPath": "可执行文件路径",
+  "instanceInfo.labels.executionProfile": "执行配置",
   "instanceInfo.labels.environmentVariables": "环境变量（{count}）",
   "instanceInfo.loading": "正在加载...",
   "instanceInfo.server.title": "服务器",
diff --git a/packages/ui/src/lib/i18n/messages/zh-Hans/messaging.ts b/packages/ui/src/lib/i18n/messages/zh-Hans/messaging.ts
index 8c2746d7d..086aa1a6b 100644
--- a/packages/ui/src/lib/i18n/messages/zh-Hans/messaging.ts
+++ b/packages/ui/src/lib/i18n/messages/zh-Hans/messaging.ts
@@ -91,6 +91,7 @@ export const messagingMessages = {
   "messageItem.actions.copy": "复制",
   "messageItem.actions.copyTitle": "复制消息",
   "messageItem.actions.copied": "已复制！",
+  "messageItem.actions.more": "更多操作",
   "messageItem.actions.speak": "朗读消息",
   "messageItem.actions.generatingSpeech": "正在生成语音",
   "messageItem.actions.stopSpeech": "停止播放",
diff --git a/packages/ui/src/lib/i18n/messages/zh-Hans/settings.ts b/packages/ui/src/lib/i18n/messages/zh-Hans/settings.ts
index beae0a580..4f8643040 100644
--- a/packages/ui/src/lib/i18n/messages/zh-Hans/settings.ts
+++ b/packages/ui/src/lib/i18n/messages/zh-Hans/settings.ts
@@ -125,6 +125,95 @@ export const settingsMessages = {
   "settings.opencode.logLevel.option.info": "信息",
   "settings.opencode.logLevel.option.warn": "警告",
   "settings.opencode.logLevel.option.error": "错误",
+  "settings.opencode.executionProfiles.title": "Execution Profiles",
+  "settings.opencode.executionProfiles.subtitle": "Define how CodeNomad should run OpenCode for local workspaces.",
+  "settings.opencode.executionProfiles.kind.local": "Local",
+  "settings.opencode.executionProfiles.kind.wsl": "WSL",
+  "settings.opencode.executionProfiles.kind.docker": "Docker",
+  "settings.opencode.executionProfiles.kind.command": "Command",
+  "settings.opencode.executionProfiles.kind.ssh": "SSH",
+  "settings.opencode.executionProfiles.form.kind.label": "Profile type",
+  "settings.opencode.executionProfiles.form.kind.subtitle": "Choose the runtime strategy for this profile.",
+  "settings.opencode.executionProfiles.form.name.label": "Profile name",
+  "settings.opencode.executionProfiles.form.name.subtitle": "Use a clear label you can recognise later.",
+  "settings.opencode.executionProfiles.form.name.placeholder": "Docker Sandbox",
+  "settings.opencode.executionProfiles.form.binaryPath.label": "Binary path",
+  "settings.opencode.executionProfiles.form.binaryPath.subtitle": "Absolute path to the OpenCode executable.",
+  "settings.opencode.executionProfiles.form.binaryPath.placeholder": "C:\\Tools\\opencode.exe",
+  "settings.opencode.executionProfiles.form.distro.label": "WSL distro",
+  "settings.opencode.executionProfiles.form.distro.subtitle": "Name of the WSL distribution to use.",
+  "settings.opencode.executionProfiles.form.distro.placeholder": "Ubuntu",
+  "settings.opencode.executionProfiles.form.image.label": "Docker image",
+  "settings.opencode.executionProfiles.form.image.subtitle": "Container image used to run OpenCode.",
+  "settings.opencode.executionProfiles.form.image.placeholder": "ghcr.io/example/opencode:latest",
+  "settings.opencode.executionProfiles.form.workspaceMountPath.label": "Workspace mount path",
+  "settings.opencode.executionProfiles.form.workspaceMountPath.subtitle": "Path inside the container where the workspace is mounted.",
+  "settings.opencode.executionProfiles.form.workspaceMountPath.placeholder": "/workspace",
+  "settings.opencode.executionProfiles.form.configMountPath.label": "Config mount path",
+  "settings.opencode.executionProfiles.form.configMountPath.subtitle": "Path inside the container where the OpenCode config directory is mounted.",
+  "settings.opencode.executionProfiles.form.configMountPath.placeholder": "/root/.config/opencode",
+  "settings.opencode.executionProfiles.form.command.label": "Container command",
+  "settings.opencode.executionProfiles.form.command.placeholder": "One argument per line",
+  "settings.opencode.executionProfiles.form.extraDockerArgs.label": "Extra Docker args",
+  "settings.opencode.executionProfiles.form.extraDockerArgs.placeholder": "One docker argument per line",
+  "settings.opencode.executionProfiles.form.executable.label": "Executable",
+  "settings.opencode.executionProfiles.form.executable.subtitle": "Program or script to launch for this profile.",
+  "settings.opencode.executionProfiles.form.executable.placeholder": "ssh",
+  "settings.opencode.executionProfiles.form.cwdMode.label": "Working directory",
+  "settings.opencode.executionProfiles.form.cwdMode.subtitle": "Choose whether the command starts in the workspace directory.",
+  "settings.opencode.executionProfiles.form.cwdMode.workspace": "Workspace folder",
+  "settings.opencode.executionProfiles.form.cwdMode.inherit": "Inherit current process cwd",
+  "settings.opencode.executionProfiles.form.args.label": "Arguments",
+  "settings.opencode.executionProfiles.form.args.placeholder": "One argument per line",
+  "settings.opencode.executionProfiles.form.sshHost.label": "SSH host",
+  "settings.opencode.executionProfiles.form.sshHost.subtitle": "Remote SSH server used to run OpenCode.",
+  "settings.opencode.executionProfiles.form.sshHost.placeholder": "vm.example.com",
+  "settings.opencode.executionProfiles.form.sshPort.label": "SSH port",
+  "settings.opencode.executionProfiles.form.sshPort.subtitle": "Port used by the remote SSH server.",
+  "settings.opencode.executionProfiles.form.sshPort.placeholder": "22",
+  "settings.opencode.executionProfiles.form.sshUsername.label": "SSH username",
+  "settings.opencode.executionProfiles.form.sshUsername.subtitle": "Optional login user for the remote host.",
+  "settings.opencode.executionProfiles.form.sshUsername.placeholder": "ubuntu",
+  "settings.opencode.executionProfiles.form.sshRemotePath.label": "Remote workspace path",
+  "settings.opencode.executionProfiles.form.sshRemotePath.subtitle": "Workspace directory on the remote SSH host.",
+  "settings.opencode.executionProfiles.form.sshRemotePath.placeholder": "/srv/project",
+  "settings.opencode.executionProfiles.form.previewWorkspacePath.label": "Preview workspace path",
+  "settings.opencode.executionProfiles.form.previewWorkspacePath.subtitle": "Optional sample workspace path used to resolve cwd and Docker mounts.",
+  "settings.opencode.executionProfiles.form.previewWorkspacePath.placeholder": "D:\\CodeNomad",
+  "settings.opencode.executionProfiles.form.test": "Test profile",
+  "settings.opencode.executionProfiles.form.testing": "Testing...",
+  "settings.opencode.executionProfiles.form.preview": "Preview command",
+  "settings.opencode.executionProfiles.form.previewing": "Previewing...",
+  "settings.opencode.executionProfiles.form.save": "Save profile",
+  "settings.opencode.executionProfiles.form.update": "Update profile",
+  "settings.opencode.executionProfiles.form.cancelEdit": "Cancel edit",
+  "settings.opencode.executionProfiles.list.title": "Saved execution profiles",
+  "settings.opencode.executionProfiles.list.subtitle": "Review and manage the execution profiles available on this server.",
+  "settings.opencode.executionProfiles.list.empty": "No execution profiles configured yet.",
+  "settings.opencode.executionProfiles.list.defaultBadge": "Default",
+  "settings.opencode.executionProfiles.list.actions.edit": "Edit profile",
+  "settings.opencode.executionProfiles.list.actions.duplicate": "Duplicate profile",
+  "settings.opencode.executionProfiles.list.actions.delete": "Delete profile",
+  "settings.opencode.executionProfiles.list.actions.makeDefault": "Set as default profile",
+  "settings.common.duplicateSuffix": "Copy",
+  "settings.opencode.executionProfiles.preview.title": "Command preview",
+  "settings.opencode.executionProfiles.preview.subtitle": "Shows the generated launcher command with current server settings. Secrets are redacted.",
+  "settings.opencode.executionProfiles.preview.commandLine": "Command line",
+  "settings.opencode.executionProfiles.preview.cwd": "Working directory",
+  "settings.opencode.executionProfiles.preview.cwd.inherit": "Inherit current process cwd",
+  "settings.opencode.executionProfiles.preview.environment": "Environment",
+  "settings.opencode.executionProfiles.test.title": "Profile test",
+  "settings.opencode.executionProfiles.test.success": "Profile check passed.",
+  "settings.opencode.executionProfiles.test.successWithVersion": "Profile check passed. Detected version: {version}",
+  "settings.opencode.executionProfiles.test.failureFallback": "Profile check failed.",
+  "settings.opencode.executionProfiles.validation.name": "Profile name is required.",
+  "settings.opencode.executionProfiles.validation.binaryPath": "Binary path is required.",
+  "settings.opencode.executionProfiles.validation.distro": "WSL distro is required.",
+  "settings.opencode.executionProfiles.validation.docker": "Docker image and mount paths are required.",
+  "settings.opencode.executionProfiles.validation.executable": "Executable is required.",
+  "settings.opencode.executionProfiles.validation.sshHost": "SSH host is required.",
+  "settings.opencode.executionProfiles.validation.sshPort": "SSH port must be between 1 and 65535.",
+  "settings.opencode.executionProfiles.validation.sshRemotePath": "Remote workspace path is required.",
 
   "settings.appearance.behavior.title": "交互",
   "settings.appearance.behavior.subtitle": "消息、差异与输入的默认值。",
diff --git a/packages/ui/src/lib/native/remote-window.ts b/packages/ui/src/lib/native/remote-window.ts
index 5237d537e..a93d41ecc 100644
--- a/packages/ui/src/lib/native/remote-window.ts
+++ b/packages/ui/src/lib/native/remote-window.ts
@@ -19,7 +19,7 @@ export async function openRemoteServerWindow(
   proxySessionId?: string,
 ): Promise<void> {
   if (!canOpenRemoteWindows()) {
-    throw new Error("Remote server windows can only be opened from a local desktop window")
+    throw new Error(tGlobal("folderSelection.servers.errorDesktopOnly"))
   }
 
   const payload: RemoteWindowOpenPayload = {
diff --git a/packages/ui/src/stores/instances.ts b/packages/ui/src/stores/instances.ts
index ccf14f160..346da4007 100644
--- a/packages/ui/src/stores/instances.ts
+++ b/packages/ui/src/stores/instances.ts
@@ -113,6 +113,9 @@ function workspaceDescriptorToInstance(descriptor: WorkspaceDescriptor): Instanc
     binaryPath: descriptor.binaryId ?? descriptor.binaryLabel ?? existing?.binaryPath,
     binaryLabel: descriptor.binaryLabel,
     binaryVersion: descriptor.binaryVersion ?? existing?.binaryVersion,
+    executionProfileId: descriptor.executionProfileId ?? existing?.executionProfileId,
+    executionProfileName: descriptor.executionProfileName ?? existing?.executionProfileName,
+    executionProfileKind: descriptor.executionProfileKind ?? existing?.executionProfileKind,
     environmentVariables: existing?.environmentVariables ?? serverSettings().environmentVariables ?? {},
   }
 }
@@ -541,9 +544,9 @@ function removeInstance(id: string) {
   syncHasInstancesFlag()
 }
 
-async function createInstance(folder: string, _binaryPath?: string): Promise<string> {
+async function createInstance(folder: string, _binaryPath?: string, options?: { executionProfileId?: string }): Promise<string> {
   try {
-    const workspace = await serverApi.createWorkspace({ path: folder })
+    const workspace = await serverApi.createWorkspace({ path: folder, executionProfileId: options?.executionProfileId })
     upsertWorkspace(workspace)
     setActiveInstanceId(workspace.id)
     return workspace.id
diff --git a/packages/ui/src/stores/preferences.tsx b/packages/ui/src/stores/preferences.tsx
index a39b07969..137f26f22 100644
--- a/packages/ui/src/stores/preferences.tsx
+++ b/packages/ui/src/stores/preferences.tsx
@@ -1,7 +1,10 @@
 import { createContext, createMemo, createSignal, onMount, useContext } from "solid-js"
 import type { Accessor, ParentComponent } from "solid-js"
 import { storage, type OwnerBucket } from "../lib/storage"
-import type { RemoteServerProfile } from "../../../server/src/api-types"
+import type {
+  ExecutionProfile,
+  RemoteServerProfile,
+} from "../../../server/src/api-types"
 import {
   ensureInstanceConfigLoaded,
   getInstanceConfig,
@@ -102,6 +105,8 @@ interface ServerConfigBucket {
   logLevel?: ServerLogLevel
   environmentVariables?: Record<string, string>
   opencodeBinary?: string
+  executionProfiles?: ExecutionProfile[]
+  defaultExecutionProfileId?: string
   speech?: Partial<SpeechSettings>
 }
 
@@ -109,6 +114,7 @@ interface UiStateBucket {
   recentFolders?: RecentFolder[]
   opencodeBinaries?: OpenCodeBinary[]
   remoteServers?: RemoteServerProfile[]
+  lastSelectedExecutionProfileId?: string
   models?: {
     recents?: ModelPreference[]
     favorites?: ModelPreference[]
@@ -120,6 +126,7 @@ interface NormalizedUiState {
   recentFolders: RecentFolder[]
   opencodeBinaries: OpenCodeBinary[]
   remoteServers: RemoteServerProfile[]
+  lastSelectedExecutionProfileId?: string
   models: {
     recents: ModelPreference[]
     favorites: ModelPreference[]
@@ -205,6 +212,96 @@ function normalizeRecord(value: unknown): Record<string, string> {
   return out
 }
 
+function normalizeStringList(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) return undefined
+  const out = value.filter((item): item is string => typeof item === "string").map((item) => item.trim()).filter((item) => item.length > 0)
+  return out.length > 0 ? out : undefined
+}
+
+function normalizeExecutionProfiles(value: unknown): ExecutionProfile[] {
+  if (!Array.isArray(value)) return []
+
+  const profiles: ExecutionProfile[] = []
+  for (const entry of value) {
+    if (!entry || typeof entry !== "object") continue
+
+    const id = typeof (entry as any).id === "string" ? (entry as any).id.trim() : ""
+    const name = typeof (entry as any).name === "string" ? (entry as any).name.trim() : ""
+    const kind = typeof (entry as any).kind === "string" ? (entry as any).kind.trim() : ""
+    if (!id || !name) continue
+
+    if (kind === "local") {
+      const binaryPath = typeof (entry as any).binaryPath === "string" ? (entry as any).binaryPath.trim() : ""
+      if (!binaryPath) continue
+      profiles.push({ id, name, kind, binaryPath })
+      continue
+    }
+
+    if (kind === "wsl") {
+      const distro = typeof (entry as any).distro === "string" ? (entry as any).distro.trim() : ""
+      const binaryPath = typeof (entry as any).binaryPath === "string" ? (entry as any).binaryPath.trim() : ""
+      if (!distro || !binaryPath) continue
+      profiles.push({ id, name, kind, distro, binaryPath })
+      continue
+    }
+
+    if (kind === "docker") {
+      const image = typeof (entry as any).image === "string" ? (entry as any).image.trim() : ""
+      const workspaceMountPath = typeof (entry as any).workspaceMountPath === "string" ? (entry as any).workspaceMountPath.trim() : ""
+      const configMountPath = typeof (entry as any).configMountPath === "string" ? (entry as any).configMountPath.trim() : ""
+      if (!image || !workspaceMountPath || !configMountPath) continue
+      profiles.push({
+        id,
+        name,
+        kind,
+        image,
+        workspaceMountPath,
+        configMountPath,
+        command: normalizeStringList((entry as any).command),
+        extraDockerArgs: normalizeStringList((entry as any).extraDockerArgs),
+      })
+      continue
+    }
+
+    if (kind === "command") {
+      const executable = typeof (entry as any).executable === "string" ? (entry as any).executable.trim() : ""
+      const cwdMode = (entry as any).cwdMode === "inherit" ? "inherit" : (entry as any).cwdMode === "workspace" ? "workspace" : undefined
+      if (!executable) continue
+      profiles.push({
+        id,
+        name,
+        kind,
+        executable,
+        args: normalizeStringList((entry as any).args),
+        cwdMode,
+      })
+      continue
+    }
+
+    if (kind === "ssh") {
+      const host = typeof (entry as any).host === "string" ? (entry as any).host.trim() : ""
+      const remotePath = typeof (entry as any).remotePath === "string" ? (entry as any).remotePath.trim() : ""
+      const binaryPath = typeof (entry as any).binaryPath === "string" ? (entry as any).binaryPath.trim() : ""
+      const port = typeof (entry as any).port === "number" && Number.isInteger((entry as any).port) ? (entry as any).port : undefined
+      const username = typeof (entry as any).username === "string" ? (entry as any).username.trim() : ""
+      if (!host || !remotePath || !binaryPath) continue
+      profiles.push({
+        id,
+        name,
+        kind,
+        host,
+        port: port && port > 0 && port <= 65535 ? port : undefined,
+        username: username || undefined,
+        remotePath,
+        binaryPath,
+        args: normalizeStringList((entry as any).args),
+      })
+    }
+  }
+
+  return profiles
+}
+
 function normalizeSpeechSettings(input?: Partial<SpeechSettings> | null): SpeechSettings {
   const sanitized = input ?? {}
   return {
@@ -245,8 +342,40 @@ function cloneArray<T>(value: unknown, mapper: (item: any) => T | null): T[] {
   return out
 }
 
+function sortByRecentActivity<T extends { lastConnectedAt?: string; updatedAt: string }>(entries: T[]): T[] {
+  return [...entries].sort((a, b) => {
+    const left = a.lastConnectedAt ?? a.updatedAt
+    const right = b.lastConnectedAt ?? b.updatedAt
+    return right.localeCompare(left)
+  })
+}
+
+function normalizeRemoteServerProfile(value: unknown): RemoteServerProfile | null {
+  if (!value || typeof value !== "object") return null
+  const id = typeof (value as any).id === "string" ? (value as any).id.trim() : ""
+  const name = typeof (value as any).name === "string" ? (value as any).name.trim() : ""
+  const baseUrl = typeof (value as any).baseUrl === "string" ? (value as any).baseUrl.trim() : ""
+  if (!id || !name || !baseUrl) return null
+  const createdAt = typeof (value as any).createdAt === "string" ? (value as any).createdAt : new Date().toISOString()
+  const updatedAt = typeof (value as any).updatedAt === "string" ? (value as any).updatedAt : createdAt
+  const lastConnectedAt = typeof (value as any).lastConnectedAt === "string" ? (value as any).lastConnectedAt : undefined
+  return {
+    id,
+    name,
+    baseUrl,
+    skipTlsVerify: Boolean((value as any).skipTlsVerify),
+    createdAt,
+    updatedAt,
+    lastConnectedAt,
+  }
+}
+
 function normalizeUiState(input?: UiStateBucket | null): NormalizedUiState {
   const source = input ?? {}
+  const remoteServers = sortByRecentActivity(
+    cloneArray<RemoteServerProfile>(source.remoteServers, (server) => normalizeRemoteServerProfile(server)),
+  )
+
   return {
     recentFolders: cloneArray<RecentFolder>(source.recentFolders, (f) => {
       if (!f || typeof f !== "object") return null
@@ -265,29 +394,11 @@ function normalizeUiState(input?: UiStateBucket | null): NormalizedUiState {
       const label = typeof (b as any).label === "string" ? (b as any).label : undefined
       return { path: p, version, label, lastUsed }
     }),
-    remoteServers: cloneArray<RemoteServerProfile>(source.remoteServers, (server) => {
-      if (!server || typeof server !== "object") return null
-      const id = typeof (server as any).id === "string" ? (server as any).id.trim() : ""
-      const name = typeof (server as any).name === "string" ? (server as any).name.trim() : ""
-      const baseUrl = typeof (server as any).baseUrl === "string" ? (server as any).baseUrl.trim() : ""
-      if (!id || !name || !baseUrl) return null
-      const createdAt = typeof (server as any).createdAt === "string" ? (server as any).createdAt : new Date().toISOString()
-      const updatedAt = typeof (server as any).updatedAt === "string" ? (server as any).updatedAt : createdAt
-      const lastConnectedAt = typeof (server as any).lastConnectedAt === "string" ? (server as any).lastConnectedAt : undefined
-      return {
-        id,
-        name,
-        baseUrl,
-        skipTlsVerify: Boolean((server as any).skipTlsVerify),
-        createdAt,
-        updatedAt,
-        lastConnectedAt,
-      }
-    }).sort((a, b) => {
-      const left = a.lastConnectedAt ?? a.updatedAt
-      const right = b.lastConnectedAt ?? b.updatedAt
-      return right.localeCompare(left)
-    }),
+    remoteServers,
+    lastSelectedExecutionProfileId:
+      typeof source.lastSelectedExecutionProfileId === "string" && source.lastSelectedExecutionProfileId.trim()
+        ? source.lastSelectedExecutionProfileId.trim()
+        : undefined,
     models: {
       recents: cloneArray<ModelPreference>((source.models as any)?.recents, (m) => {
         if (!m || typeof m !== "object") return null
@@ -310,7 +421,11 @@ function normalizeUiState(input?: UiStateBucket | null): NormalizedUiState {
 
 function normalizeServerConfig(
   input?: ServerConfigBucket | null,
-): Required<Pick<ServerConfigBucket, "listeningMode" | "logLevel" | "environmentVariables" | "opencodeBinary">> & { speech: SpeechSettings } {
+): Required<Pick<ServerConfigBucket, "listeningMode" | "logLevel" | "environmentVariables" | "opencodeBinary">> & {
+  executionProfiles: ExecutionProfile[]
+  defaultExecutionProfileId?: string
+  speech: SpeechSettings
+} {
   const source = input ?? {}
   const listeningMode = source.listeningMode === "all" ? "all" : "local"
   const logLevel =
@@ -319,8 +434,13 @@ function normalizeServerConfig(
       : "DEBUG"
   const opencodeBinary = typeof source.opencodeBinary === "string" && source.opencodeBinary.trim() ? source.opencodeBinary : "opencode"
   const environmentVariables = normalizeRecord(source.environmentVariables)
+  const executionProfiles = normalizeExecutionProfiles(source.executionProfiles)
+  const defaultExecutionProfileId =
+    typeof source.defaultExecutionProfileId === "string" && executionProfiles.some((profile) => profile.id === source.defaultExecutionProfileId)
+      ? source.defaultExecutionProfileId
+      : undefined
   const speech = normalizeSpeechSettings(source.speech)
-  return { listeningMode, logLevel, opencodeBinary, environmentVariables, speech }
+  return { listeningMode, logLevel, opencodeBinary, environmentVariables, executionProfiles, defaultExecutionProfileId, speech }
 }
 
 function getModelKey(model: { providerId: string; modelId: string }): string {
@@ -370,11 +490,12 @@ function buildRemoteServerProfile(input: RemoteServerProfileInput, source: Remot
 
 function buildRemoteServerList(profile: RemoteServerProfile, source: RemoteServerProfile[]): RemoteServerProfile[] {
   const remaining = source.filter((entry) => entry.id !== profile.id)
-  return [profile, ...remaining].sort((a, b) => {
-    const left = a.lastConnectedAt ?? a.updatedAt
-    const right = b.lastConnectedAt ?? b.updatedAt
-    return right.localeCompare(left)
-  })
+  return sortByRecentActivity([profile, ...remaining])
+}
+
+function buildExecutionProfileList(profile: ExecutionProfile, source: ExecutionProfile[]): ExecutionProfile[] {
+  const remaining = source.filter((entry) => entry.id !== profile.id)
+  return [profile, ...remaining]
 }
 
 function createRandomId(): string {
@@ -398,6 +519,9 @@ const preferences = uiSettings
 const recentFolders = createMemo<RecentFolder[]>(() => uiState().recentFolders)
 const opencodeBinaries = createMemo<OpenCodeBinary[]>(() => uiState().opencodeBinaries)
 const remoteServers = createMemo<RemoteServerProfile[]>(() => uiState().remoteServers)
+const lastSelectedExecutionProfileId = createMemo<string | undefined>(() => uiState().lastSelectedExecutionProfileId)
+const executionProfiles = createMemo<ExecutionProfile[]>(() => serverSettings().executionProfiles)
+const defaultExecutionProfileId = createMemo<string | undefined>(() => serverSettings().defaultExecutionProfileId)
 
 let loadPromise: Promise<void> | null = null
 
@@ -560,8 +684,40 @@ async function markRemoteServerConnected(id: string): Promise<void> {
 }
 
 function removeRemoteServerProfile(id: string): void {
-  const next = remoteServers().filter((entry) => entry.id !== id)
-  void patchStateOwner("ui", { remoteServers: next }).catch((error) => log.error("Failed to remove remote server", error))
+  const nextRemoteServers = remoteServers().filter((entry) => entry.id !== id)
+  void patchStateOwner("ui", { remoteServers: nextRemoteServers }).catch((error) => log.error("Failed to remove remote server profile", error))
+}
+
+function setLastSelectedExecutionProfileId(profileId: string | undefined): void {
+  const nextId = profileId?.trim() || undefined
+  void patchStateOwner("ui", { lastSelectedExecutionProfileId: nextId }).catch((error) =>
+    log.error("Failed to save last selected execution profile", error),
+  )
+}
+
+async function saveExecutionProfile(profile: ExecutionProfile): Promise<ExecutionProfile> {
+  const nextProfiles = buildExecutionProfileList(profile, executionProfiles())
+  const nextDefaultExecutionProfileId = defaultExecutionProfileId() ?? profile.id
+  await patchConfigOwner("server", {
+    executionProfiles: nextProfiles,
+    defaultExecutionProfileId: nextDefaultExecutionProfileId,
+  })
+  return profile
+}
+
+async function setDefaultExecutionProfileId(profileId: string | undefined): Promise<void> {
+  const trimmed = profileId?.trim()
+  const nextDefault = trimmed && executionProfiles().some((profile) => profile.id === trimmed) ? trimmed : undefined
+  await patchConfigOwner("server", { defaultExecutionProfileId: nextDefault })
+}
+
+function removeExecutionProfile(profileId: string): void {
+  const nextProfiles = executionProfiles().filter((profile) => profile.id !== profileId)
+  const nextDefault = defaultExecutionProfileId() === profileId ? nextProfiles[0]?.id : defaultExecutionProfileId()
+  void patchConfigOwner("server", {
+    executionProfiles: nextProfiles,
+    defaultExecutionProfileId: nextDefault,
+  }).catch((error) => log.error("Failed to remove execution profile", error))
 }
 
 function recordWorkspaceLaunch(folderPath: string, binaryPath?: string): void {
@@ -720,6 +876,8 @@ interface ConfigContextValue {
 
   // server-owned stable config
   serverSettings: typeof serverSettings
+  executionProfiles: typeof executionProfiles
+  defaultExecutionProfileId: typeof defaultExecutionProfileId
   setListeningMode: typeof setListeningMode
   updateEnvironmentVariables: typeof updateEnvironmentVariables
   addEnvironmentVariable: typeof addEnvironmentVariable
@@ -727,16 +885,21 @@ interface ConfigContextValue {
     updateLastUsedBinary: typeof updateLastUsedBinary
     updateLogLevel: typeof updateLogLevel
     updateSpeechSettings: typeof updateSpeechSettings
+    saveExecutionProfile: typeof saveExecutionProfile
+    setDefaultExecutionProfileId: typeof setDefaultExecutionProfileId
+    removeExecutionProfile: typeof removeExecutionProfile
 
   // ui-owned state
   recentFolders: typeof recentFolders
   opencodeBinaries: typeof opencodeBinaries
   remoteServers: typeof remoteServers
+  lastSelectedExecutionProfileId: typeof lastSelectedExecutionProfileId
   uiState: typeof uiState
   addRecentFolder: typeof addRecentFolder
   removeRecentFolder: typeof removeRecentFolder
   addOpenCodeBinary: typeof addOpenCodeBinary
   removeOpenCodeBinary: typeof removeOpenCodeBinary
+  setLastSelectedExecutionProfileId: typeof setLastSelectedExecutionProfileId
   saveRemoteServerProfile: typeof saveRemoteServerProfile
   markRemoteServerConnected: typeof markRemoteServerConnected
   removeRemoteServerProfile: typeof removeRemoteServerProfile
@@ -776,6 +939,8 @@ const configContextValue: ConfigContextValue = {
   themePreference,
   setThemePreference,
   serverSettings,
+  executionProfiles,
+  defaultExecutionProfileId,
   setListeningMode,
   updateEnvironmentVariables,
   addEnvironmentVariable,
@@ -783,14 +948,19 @@ const configContextValue: ConfigContextValue = {
   updateLastUsedBinary,
   updateLogLevel,
   updateSpeechSettings,
+  saveExecutionProfile,
+  setDefaultExecutionProfileId,
+  removeExecutionProfile,
   recentFolders,
   opencodeBinaries,
   remoteServers,
+  lastSelectedExecutionProfileId,
   uiState,
   addRecentFolder,
   removeRecentFolder,
   addOpenCodeBinary,
   removeOpenCodeBinary,
+  setLastSelectedExecutionProfileId,
   saveRemoteServerProfile,
   markRemoteServerConnected,
   removeRemoteServerProfile,
@@ -860,8 +1030,11 @@ export {
   preferences,
   uiState,
   serverSettings,
+  executionProfiles,
+  defaultExecutionProfileId,
   recentFolders,
   opencodeBinaries,
+  lastSelectedExecutionProfileId,
   themePreference,
   setThemePreference,
   updatePreferences,
@@ -872,10 +1045,14 @@ export {
   updateLastUsedBinary,
   updateLogLevel,
   updateSpeechSettings,
+  saveExecutionProfile,
+  setDefaultExecutionProfileId,
+  removeExecutionProfile,
   addRecentFolder,
   removeRecentFolder,
   addOpenCodeBinary,
   removeOpenCodeBinary,
+  setLastSelectedExecutionProfileId,
   recordWorkspaceLaunch,
   addRecentModelPreference,
   isFavoriteModelPreference,
diff --git a/packages/ui/src/styles/components/dropdown.css b/packages/ui/src/styles/components/dropdown.css
index 75bbf5c4a..b85e6b4ad 100644
--- a/packages/ui/src/styles/components/dropdown.css
+++ b/packages/ui/src/styles/components/dropdown.css
@@ -70,3 +70,62 @@
 .dropdown-icon-accent {
   color: var(--accent-primary);
 }
+
+.action-overflow-trigger {
+  display: none;
+}
+
+.action-overflow-content {
+  min-width: 12rem;
+  padding: 0.25rem;
+  border: 1px solid var(--border-base);
+  border-radius: 0;
+  background-color: var(--surface-base);
+  box-shadow: var(--popover-shadow);
+  color: var(--text-primary);
+  z-index: 1000;
+}
+
+.action-overflow-item {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  width: 100%;
+  min-height: 2rem;
+  padding: 0.4rem 0.5rem;
+  border-radius: 0;
+  font-size: 0.8125rem;
+  line-height: 1.2;
+  color: var(--text-primary);
+  cursor: pointer;
+  user-select: none;
+  outline: none;
+}
+
+.action-overflow-item:hover,
+.action-overflow-item[data-highlighted] {
+  background-color: var(--surface-hover);
+}
+
+.action-overflow-item[data-disabled] {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+.action-overflow-item[data-destructive="true"] {
+  color: var(--status-error);
+}
+
+.action-overflow-item-icon {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 1rem;
+  height: 1rem;
+  flex: 0 0 auto;
+}
+
+.action-overflow-item-label {
+  min-width: 0;
+  flex: 1 1 auto;
+}
diff --git a/packages/ui/src/styles/messaging/message-base.css b/packages/ui/src/styles/messaging/message-base.css
index 5b290f89a..92af35daa 100644
--- a/packages/ui/src/styles/messaging/message-base.css
+++ b/packages/ui/src/styles/messaging/message-base.css
@@ -113,6 +113,18 @@
   transform: scale(0.95);
 }
 
+.message-item-actions > .action-overflow-trigger {
+  display: none;
+}
+
+.session-center-column[data-session-center-width="narrow"] .message-item-actions[data-action-overflow="true"] .message-action-group {
+  display: none;
+}
+
+.session-center-column[data-session-center-width="narrow"] .message-item-actions[data-action-overflow="true"] > .action-overflow-trigger {
+  display: inline-flex;
+}
+
 .message-timestamp {
   @apply text-[11px] text-[var(--text-muted)];
 }
@@ -433,10 +445,22 @@
 .message-reasoning-actions {
   display: inline-flex;
   align-items: center;
-  gap: 0.5rem;
+  gap: 0;
   padding: 0.25rem 0.6rem 0.25rem 0;
 }
 
+.message-reasoning-actions > .action-overflow-trigger {
+  display: none;
+}
+
+.session-center-column[data-session-center-width="narrow"] .message-reasoning-actions[data-action-overflow="true"] > .message-action-button:not(.message-reasoning-primary-action):not(.action-overflow-trigger) {
+  display: none;
+}
+
+.session-center-column[data-session-center-width="narrow"] .message-reasoning-actions[data-action-overflow="true"] > .action-overflow-trigger {
+  display: inline-flex;
+}
+
 .message-reasoning-toggle:hover {
   background-color: transparent;
 }
diff --git a/packages/ui/src/styles/messaging/tool-call.css b/packages/ui/src/styles/messaging/tool-call.css
index f75feaae8..3758cd521 100644
--- a/packages/ui/src/styles/messaging/tool-call.css
+++ b/packages/ui/src/styles/messaging/tool-call.css
@@ -49,6 +49,18 @@
   cursor: not-allowed;
 }
 
+.tool-call-header-label > .action-overflow-trigger {
+  display: none;
+}
+
+.session-center-column[data-session-center-width="narrow"] .tool-call-header-label[data-action-overflow="true"] .tool-call-header-actions {
+  display: none;
+}
+
+.session-center-column[data-session-center-width="narrow"] .tool-call-header-label[data-action-overflow="true"] > .action-overflow-trigger {
+  display: inline-flex;
+}
+
 .tool-call-header-label .tool-call-icon {
   @apply text-base;
 }
@@ -151,6 +163,19 @@
   color: var(--text-primary);
 }
 
+.tool-call-header > .action-overflow-trigger {
+  display: none;
+}
+
+.session-center-column[data-session-center-width="narrow"] .tool-call-header[data-action-overflow="true"] > .tool-call-header-input,
+.session-center-column[data-session-center-width="narrow"] .tool-call-header[data-action-overflow="true"] > .tool-call-header-copy:not(.action-overflow-trigger) {
+  display: none;
+}
+
+.session-center-column[data-session-center-width="narrow"] .tool-call-header[data-action-overflow="true"] > .action-overflow-trigger {
+  display: inline-flex;
+}
+
 .tool-call-header-status {
   @apply inline-flex items-center justify-center;
   font-size: 0.95rem;
diff --git a/packages/ui/src/types/instance.ts b/packages/ui/src/types/instance.ts
index 71486150d..a52047e93 100644
--- a/packages/ui/src/types/instance.ts
+++ b/packages/ui/src/types/instance.ts
@@ -43,5 +43,8 @@ export interface Instance {
   binaryPath?: string
   binaryLabel?: string
   binaryVersion?: string
+  executionProfileId?: string
+  executionProfileName?: string
+  executionProfileKind?: "local" | "wsl" | "docker" | "command" | "ssh"
   environmentVariables?: Record<string, string>
 }