diff --git a/packages/app/e2e/regression/settings.spec.ts b/packages/app/e2e/regression/settings.spec.ts
index 6ac6987f7a0d..0fe8cf453faf 100644
--- a/packages/app/e2e/regression/settings.spec.ts
+++ b/packages/app/e2e/regression/settings.spec.ts
@@ -799,8 +799,18 @@ const consoleIntegrations = [
 ]
 
 for (const row of [
-  { provider: "OpenCode Console", connect: "Connect OpenCode Console", signIn: "Connecting to OpenCode Console" },
-  { provider: "OpenCode Go", connect: "Connect OpenCode Go", signIn: "Connecting to OpenCode Go" },
+  {
+    provider: "OpenCode Console",
+    connect: "Connect OpenCode",
+    signIn: "Connecting to OpenCode",
+    keys: ["Zen API key", "Go API key"],
+  },
+  {
+    provider: "OpenCode Go",
+    connect: "Connect OpenCode Go",
+    signIn: "Connecting to OpenCode Go",
+    keys: ["Use API key"],
+  },
 ]) {
   test(`providers: ${row.provider} signs in from the Console intro`, async ({ page, context }) => {
     const url = "https://auth.example.test/device?user_code=ABCD-EFGH"
@@ -820,9 +830,9 @@ for (const row of [
     const intro = page.getByRole("dialog", { name: row.connect, exact: true })
     const container = page.locator('[data-slot="dialog-container"]')
     await expect(
-      intro.getByText("Sign in with your OpenCode Console account to use the available models."),
+      intro.getByText("Sign in with your OpenCode account to use your Go subscription or Console workspace."),
     ).toBeVisible()
-    await expect(intro.getByRole("button", { name: "Use API key", exact: true })).toBeVisible()
+    for (const key of row.keys) await expect(intro.getByRole("button", { name: key, exact: true })).toBeVisible()
     expect((await container.boundingBox())?.height).toBe(512)
 
     const popup = page.waitForEvent("popup")
@@ -836,11 +846,125 @@ for (const row of [
     const signIn = page.getByRole("dialog", { name: row.signIn, exact: true })
     await expect(signIn.getByRole("group", { name: "Device code: ABCD-EFGH", exact: true })).toBeVisible()
     await expect(signIn.getByRole("button", { name: "Copy sign-in link", exact: true })).toBeVisible()
-    await expect(signIn.getByRole("button", { name: "Use API key", exact: true })).toHaveCount(0)
+    for (const key of row.keys) await expect(signIn.getByRole("button", { name: key, exact: true })).toHaveCount(0)
     await expect.poll(async () => (await container.boundingBox())?.height).toBeLessThan(512)
   })
 }
 
+// The OpenCode row stores a Zen key under `opencode` and a Go key under `opencode-go`; sign-in stays with `opencode`.
+// Before connecting, only the keyless OpenCode catalog exists, so the connection counts as the first one (any other
+// provider with models would count as an existing connection). Connecting adds the Go, integration-less and Console
+// workspace providers in the same refresh, so the "Connected to" step must pick only the ones for this connection.
+function openCodeCatalog(state: { connected: boolean }) {
+  const model = (id: string, name: string) => ({
+    [id]: { id, name, cost: { input: 0, output: 0 }, limit: { context: 200_000 } },
+  })
+
+  return () => ({
+    all: [
+      { id: "opencode", integrationID: "opencode", name: "OpenCode", models: model("zen-model", "Zen Model") },
+      ...(state.connected
+        ? [
+            {
+              id: "opencode-go",
+              integrationID: "opencode-go",
+              name: "OpenCode Go",
+              models: model("glm-5-go", "GLM-5 Go"),
+            },
+            { id: "local", name: "Local", models: model("local-model", "Local Model") },
+            {
+              id: "workspace",
+              integrationID: "opencode",
+              name: "Workspace",
+              models: model("workspace-model", "Workspace Model"),
+            },
+          ]
+        : []),
+    ],
+    connected: [],
+  })
+}
+
+for (const row of [
+  { key: "Zen API key", integrationID: "opencode", models: ["Zen Model"], hidden: ["Local Model", "GLM-5 Go"] },
+  { key: "Go API key", integrationID: "opencode-go", models: ["GLM-5 Go"], hidden: ["Local Model"] },
+]) {
+  test(`providers: the OpenCode row stores a ${row.key} under ${row.integrationID}`, async ({ page }) => {
+    const state = { connected: false }
+    const keys: Array<{ integrationID: string; body: unknown }> = []
+    const { settings } = await open(page, {
+      integrations: consoleIntegrations,
+      provider: openCodeCatalog(state),
+      onConnectKey: (input) => {
+        keys.push(input)
+        state.connected = true
+      },
+    })
+
+    await settings.getByRole("tab", { name: "Providers", exact: true }).click()
+    await settings
+      .locator(".settings-provider-row", { hasText: "OpenCode Console" })
+      .getByRole("button", { name: "Connect", exact: true })
+      .click()
+    const dialog = page.getByRole("dialog")
+    await dialog.getByRole("button", { name: row.key, exact: true }).click()
+    await dialog.getByPlaceholder("API key").fill("sk-test")
+    await dialog.getByRole("button", { name: "Continue", exact: true }).click()
+
+    await expect.poll(() => keys).toEqual([{ integrationID: row.integrationID, body: { key: "sk-test" } }])
+    const connected = page.getByRole("dialog", { name: /^Connected to / })
+    for (const name of row.models) await expect(connected.getByRole("radio", { name, exact: true })).toBeVisible()
+    for (const name of row.hidden) await expect(connected.getByRole("radio", { name, exact: true })).toHaveCount(0)
+  })
+}
+
+test("providers: going back from the Go key to sign in connects only the Console workspace", async ({
+  page,
+  context,
+}) => {
+  const url = "https://auth.example.test/device?user_code=ABCD-EFGH"
+  const state = { connected: false }
+  const keys: string[] = []
+  const oauth: string[] = []
+  await context.route("https://auth.example.test/**", (route) => route.fulfill({ body: "Sign in" }))
+  const { settings } = await open(page, {
+    integrations: consoleIntegrations,
+    provider: openCodeCatalog(state),
+    onConnectKey: (input) => keys.push(input.integrationID),
+    onIntegrationOAuth: (input) => {
+      oauth.push(input.integrationID)
+
+      return { url }
+    },
+    onIntegrationOAuthStatus: () => {
+      state.connected = true
+
+      return "complete"
+    },
+  })
+
+  await settings.getByRole("tab", { name: "Providers", exact: true }).click()
+  await settings
+    .locator(".settings-provider-row", { hasText: "OpenCode Console" })
+    .getByRole("button", { name: "Connect", exact: true })
+    .click()
+  const dialog = page.getByRole("dialog")
+  await dialog.getByRole("button", { name: "Go API key", exact: true }).click()
+  await expect(dialog.getByPlaceholder("API key")).toBeVisible()
+  await dialog.getByRole("button", { name: "Navigate back", exact: true }).click()
+
+  const popup = page.waitForEvent("popup")
+  await dialog.getByRole("button", { name: "Continue in the browser", exact: true }).click()
+  await expect(await popup).toHaveURL(url)
+
+  const connected = page.getByRole("dialog", { name: /^Connected to / })
+  await expect(connected.getByRole("radio", { name: "Workspace Model", exact: true })).toBeVisible()
+  await expect(connected.getByRole("radio", { name: "GLM-5 Go", exact: true })).toHaveCount(0)
+  await expect(connected.getByRole("radio", { name: "Local Model", exact: true })).toHaveCount(0)
+  expect(oauth).toEqual(["opencode"])
+  expect(keys).toEqual([])
+})
+
 test("providers: the connect dialog lists connected providers and manages their accounts", async ({ page }) => {
   const accounts = [
     { type: "credential", id: "cred_work", label: "Work", method: "key" },
diff --git a/packages/app/src/providers/connect/dialog.tsx b/packages/app/src/providers/connect/dialog.tsx
index 15fe5379bf3b..91b3c0485f6c 100644
--- a/packages/app/src/providers/connect/dialog.tsx
+++ b/packages/app/src/providers/connect/dialog.tsx
@@ -52,7 +52,7 @@ import {
 import { ConsoleAuthorization } from "./console"
 import { DialogChatGPTPlanWelcome } from "./chatgpt-welcome"
 import { authServerName, RemoteAuthNotice } from "./remote"
-import { providerAccounts, type ProviderAccount } from "@/settings/providers/accounts"
+import { connectPickerIntegrations, providerAccounts, type ProviderAccount } from "@/settings/providers/accounts"
 import { AccountNameInput } from "@/settings/providers/account-name"
 import { useProviderAccountActions } from "@/settings/providers/account-actions"
 import { IconButton } from "@opencode/ui/icon-button"
@@ -237,18 +237,27 @@ function ProviderPicker(props: { directory?: string; onSelect: (provider: string
     filter: "",
   })
 
-  const featured = ["opencode-go", "opencode", "anthropic", "openai", "google", "openrouter", "vercel"]
+  const featured = ["opencode", "opencode-go", "anthropic", "openai", "google", "openrouter", "vercel"]
   const custom = () => ({ id: CUSTOM_ID, name: language.t("dialog.provider.custom.label") })
 
   const all = createMemo(() => {
     language.locale()
     const query = store.filter.trim().toLowerCase()
 
-    const values = [custom(), ...integrations.list()]
+    const values = [
+      custom(),
+      ...connectPickerIntegrations(integrations.list()).map((provider) =>
+        provider.id === "opencode" ? { ...provider, name: language.t("dialog.provider.opencode.name") } : provider,
+      ),
+    ]
 
     if (!query) return values
 
-    return values.filter((provider) => `${provider.id} ${provider.name}`.toLowerCase().includes(query))
+    return values.filter((provider) =>
+      `${provider.id} ${provider.name} ${provider.id === "opencode" ? "go zen console" : ""}`
+        .toLowerCase()
+        .includes(query),
+    )
   })
 
   const popular = createMemo(() =>
@@ -363,11 +372,7 @@ function ProviderPicker(props: { directory?: string; onSelect: (provider: string
                         </Show>
                         <Show when={CONSOLE_PROVIDERS.has(provider.id) && accountCount(provider) === 0}>
                           <span class="min-w-0 truncate font-[440] text-v2-text-text-muted">
-                            {language.t(
-                              provider.id === "opencode"
-                                ? "dialog.provider.opencode.tagline"
-                                : "dialog.provider.opencodeGo.tagline",
-                            )}
+                            {language.t("dialog.provider.opencodeAll.tagline")}
                           </span>
                           <span class="flex h-4 shrink-0 items-center rounded-xs border-[0.5px] border-v2-border-border-base bg-v2-background-bg-layer-03 px-1 text-[11px] font-[530] leading-none tracking-[0.05px] text-v2-text-text-muted">
                             {language.t("dialog.provider.tag.recommended")}
@@ -450,6 +455,8 @@ function ProviderConnection(props: {
     switching?: string
     activating?: string
     renaming?: string
+    /** The OpenCode row stores a Go API key under `opencode-go`. */
+    keyProvider?: string
   }>({
     adding: false,
     direct: false,
@@ -473,11 +480,14 @@ function ProviderConnection(props: {
 
   const showAccounts = () => !!props.accounts && !state.adding && accounts().length > 0
 
+  // Only a key attempt uses the picked key provider, so going back to sign in never reaches Go's providers.
+  const keyProvider = () => (controller.currentMethod()?.type === "key" ? state.keyProvider : undefined)
+
   const controller = createProviderConnectionController({
     provider: () => integrationID,
     // A Go service-account key still belongs to the `opencode-go` integration (zen/go/v1),
     // exactly as before; only the sign-in is shared with the Console.
-    keyProvider: () => props.provider,
+    keyProvider: () => keyProvider() ?? props.provider,
     directory,
     manual: () => isConsole || (!!props.accounts && accounts().length > 0),
     prepare: isConsole ? prepareConsoleCatalog : undefined,
@@ -534,7 +544,10 @@ function ProviderConnection(props: {
 
   const connectionProviders = createMemo(() =>
     (data.location.provider.list(location()) ?? []).filter(
-      (provider) => provider.id === props.provider || provider.integrationID === integrationID,
+      (provider) =>
+        provider.id === props.provider ||
+        provider.integrationID === integrationID ||
+        (keyProvider() !== undefined && provider.integrationID === keyProvider()),
     ),
   )
 
@@ -619,10 +632,12 @@ function ProviderConnection(props: {
   const provider = createMemo(() => ({
     id: props.provider,
     name:
-      integrations.list().find((item) => item.id === props.provider)?.name ??
-      providers.all().get(props.provider)?.name ??
-      controller.integration()?.name ??
-      props.provider,
+      props.provider === "opencode"
+        ? language.t("dialog.provider.opencode.name")
+        : (integrations.list().find((item) => item.id === props.provider)?.name ??
+          providers.all().get(props.provider)?.name ??
+          controller.integration()?.name ??
+          props.provider),
   }))
 
   const methodLabel = (value?: { type?: string; label?: string }) => {
@@ -1040,7 +1055,9 @@ function ProviderConnection(props: {
         </p>
         <form onSubmit={handleSubmit} class="flex flex-col items-start gap-5 self-stretch">
           <label class="flex w-full flex-col gap-2 font-[530] leading-4 text-v2-text-text-base">
-            {language.t("provider.connect.apiKey.label", { provider: provider().name })}
+            {language.t("provider.connect.apiKey.label", {
+              provider: props.provider !== "opencode" ? provider().name : keyProvider() ? "Go" : "Zen",
+            })}
             <TextInput
               ref={apiKey}
               class="!w-full"
@@ -1320,14 +1337,27 @@ function ProviderConnection(props: {
         <Show when={keyIndex() !== -1}>
           <div data-component="console-service-account" class="flex h-7 items-center gap-1 text-[13px]">
             <span class="text-v2-text-text-faint">{language.t("provider.connect.console.serviceAccount")}</span>
-            <Button
-              variant="ghost-muted"
-              data-action="provider-connect-api-key"
-              disabled={consoleStarting()}
-              onClick={() => void controller.auth.select(keyIndex())}
-            >
-              {language.t("provider.connect.console.useApiKey")}
-            </Button>
+            <For each={props.provider === "opencode" ? [undefined, "opencode-go"] : [undefined]}>
+              {(keyProvider) => (
+                <Button
+                  variant="ghost-muted"
+                  data-action="provider-connect-api-key"
+                  disabled={consoleStarting()}
+                  onClick={() => {
+                    setState("keyProvider", keyProvider)
+                    void controller.auth.select(keyIndex())
+                  }}
+                >
+                  {language.t(
+                    props.provider !== "opencode"
+                      ? "provider.connect.console.useApiKey"
+                      : keyProvider
+                        ? "provider.connect.opencode.goKey"
+                        : "provider.connect.opencode.zenKey",
+                  )}
+                </Button>
+              )}
+            </For>
           </div>
         </Show>
       </div>
@@ -1545,9 +1575,6 @@ function ProviderConnection(props: {
                 >
                   {language.t("provider.connect.title.anthropicProMax")}
                 </Match>
-                <Match when={props.provider === "opencode"}>
-                  {language.t("provider.connect.title", { provider: language.t("provider.connect.opencode.name") })}
-                </Match>
                 <Match when={true}>{language.t("provider.connect.title", { provider: provider().name })}</Match>
               </Switch>
             </DialogTitle>
diff --git a/packages/app/src/runtime/i18n/en.ts b/packages/app/src/runtime/i18n/en.ts
index 6ee0b5aaffaa..b68383c3a0b3 100644
--- a/packages/app/src/runtime/i18n/en.ts
+++ b/packages/app/src/runtime/i18n/en.ts
@@ -102,6 +102,8 @@ export const dict = {
   "dialog.provider.opencode.note": "Curated models including Claude, GPT, Gemini and more",
   "dialog.provider.opencode.tagline": "Reliable optimized models",
   "dialog.provider.opencodeGo.tagline": "Low cost subscription for everyone",
+  "dialog.provider.opencode.name": "OpenCode",
+  "dialog.provider.opencodeAll.tagline": "Go subscription or Zen API key",
   "dialog.provider.anthropic.note": "Direct access to Claude models via API key",
   "dialog.provider.copilot.note": "AI models for coding assistance via GitHub Copilot",
   "dialog.provider.openai.note": "GPT models for fast, capable general AI tasks",
@@ -134,12 +136,15 @@ export const dict = {
   "provider.connect.opencode.name": "OpenCode Console",
   "provider.connect.opencode.freeName": "OpenCode Free",
   "provider.connect.opencode.errorTitle": "Connect to OpenCode",
-  "provider.connect.console.title": "Connecting to OpenCode Console",
+  "provider.connect.console.title": "Connecting to OpenCode",
   "provider.connect.console.titleGo": "Connecting to OpenCode Go",
-  "provider.connect.console.intro": "Sign in with your OpenCode Console account to use the available models.",
+  "provider.connect.console.intro":
+    "Sign in with your OpenCode account to use your Go subscription or Console workspace.",
+  "provider.connect.opencode.zenKey": "Zen API key",
+  "provider.connect.opencode.goKey": "Go API key",
   "provider.connect.console.continue": "Continue in the browser",
   "provider.connect.console.retry": "Try again",
-  "provider.connect.console.serviceKeyDescription": "Connect using a service-account API key from OpenCode Console.",
+  "provider.connect.console.serviceKeyDescription": "Paste an API key from OpenCode Console.",
   "provider.connect.console.instructions":
     "Continue in your browser. Confirm the code shown there matches the one below.",
   "provider.connect.console.deviceCode": "Device code",
@@ -176,7 +181,7 @@ export const dict = {
   "provider.connect.console.modelsLoading": "Your models are still loading. Refresh to check again.",
   "provider.connect.console.refresh": "Refresh models",
   "provider.connect.console.openingBrowser": "Opening browser…",
-  "provider.connect.console.serviceAccount": "Service account?",
+  "provider.connect.console.serviceAccount": "Have an API key?",
   "provider.connect.console.useApiKey": "Use API key",
   "provider.connect.remote.title": "Connecting on “{{server}}”",
   "provider.connect.remote.description":
diff --git a/packages/app/src/settings/providers/accounts.test.ts b/packages/app/src/settings/providers/accounts.test.ts
index 1e0cb3867b70..2e66928d497b 100644
--- a/packages/app/src/settings/providers/accounts.test.ts
+++ b/packages/app/src/settings/providers/accounts.test.ts
@@ -1,6 +1,6 @@
 import { expect, test } from "bun:test"
 import type { IntegrationInfo } from "@opencode/client/promise"
-import { activeProviderAccount, providerAccounts } from "./accounts"
+import { activeProviderAccount, connectPickerIntegrations, providerAccounts } from "./accounts"
 
 const integration = (connections: IntegrationInfo["connections"]): IntegrationInfo => ({
   id: "openai",
@@ -27,3 +27,24 @@ test("provider accounts keep the server's active-first credential order and igno
   expect(activeProviderAccount(env)).toBeUndefined()
   expect(providerAccounts(undefined)).toEqual([])
 })
+
+test("the connect picker folds OpenCode Go into the OpenCode row unless a Go API key is saved", () => {
+  const go = (connections: IntegrationInfo["connections"]): IntegrationInfo => ({
+    id: "opencode-go",
+    name: "OpenCode Go",
+    methods: [{ type: "key" }],
+    connections,
+  })
+  const opencode: IntegrationInfo = { id: "opencode", name: "OpenCode Console", methods: [], connections: [] }
+
+  expect(connectPickerIntegrations([go([]), opencode]).map((item) => item.id)).toEqual(["opencode"])
+  expect(
+    connectPickerIntegrations([go([{ type: "env", name: "OPENCODE_API_KEY" }]), opencode]).map((item) => item.id),
+  ).toEqual(["opencode"])
+  expect(
+    connectPickerIntegrations([
+      go([{ type: "credential", id: "cred_go", label: "Go key", method: "key" }]),
+      opencode,
+    ]).map((item) => item.id),
+  ).toEqual(["opencode-go", "opencode"])
+})
diff --git a/packages/app/src/settings/providers/accounts.ts b/packages/app/src/settings/providers/accounts.ts
index d3abd849f9fb..00e3f8a98d35 100644
--- a/packages/app/src/settings/providers/accounts.ts
+++ b/packages/app/src/settings/providers/accounts.ts
@@ -9,3 +9,9 @@ export function providerAccounts(integration: IntegrationInfo | undefined) {
 export function activeProviderAccount(integration: IntegrationInfo | undefined) {
   return providerAccounts(integration)[0]
 }
+
+// Go is an OpenCode account with a subscription, so the connect picker shows one OpenCode row for Go, Zen and
+// Console. A saved Go API key keeps its own row, where it is managed.
+export function connectPickerIntegrations(list: IntegrationInfo[]) {
+  return list.filter((integration) => integration.id !== "opencode-go" || providerAccounts(integration).length > 0)
+}
diff --git a/packages/tui/src/component/dialog-integration.tsx b/packages/tui/src/component/dialog-integration.tsx
index 183e8df3af9f..3cac21fd601f 100644
--- a/packages/tui/src/component/dialog-integration.tsx
+++ b/packages/tui/src/component/dialog-integration.tsx
@@ -47,8 +47,7 @@ import {
 } from "../util/form"
 
 const INTEGRATION_PRIORITY: Record<string, number> = {
-  "opencode-go": 0,
-  opencode: 1,
+  opencode: 0,
   openai: 2,
   "github-copilot": 3,
   anthropic: 4,
@@ -66,8 +65,48 @@ const SUBMIT = Symbol("submit")
 // Device-flow codes such as "R283-GOUEO"; when present they are copied instead of the URL.
 const OAUTH_CODE = /[A-Z0-9]{4}-[A-Z0-9]{4,5}/
 
+// The integration that runs a merged row's method, when it isn't the row's own.
+const METHOD_OWNER = new WeakMap<ConnectMethod, IntegrationInfo>()
+
+// Go is an OpenCode account with a subscription, so /connect shows one OpenCode row: sign in with the
+// account (Go or Console), or paste a Zen or Go API key. Go's own connections stay manageable here.
+export function foldOpenCode(list: IntegrationInfo[]): IntegrationInfo[] {
+  const go = list.find((item) => item.id === "opencode-go")
+  if (!go || !list.some((item) => item.id === "opencode")) return list
+  const goKeys = connectMethods(go).flatMap((method) => {
+    if (method.type !== "key") return []
+    const folded = { ...method, label: "Use a Go API key" }
+    METHOD_OWNER.set(folded, go)
+    return [folded]
+  })
+  return list.flatMap((item) => {
+    if (item.id === go.id) return []
+    if (item.id !== "opencode") return [item]
+    const methods = connectMethods(item).map((method) => ({
+      ...method,
+      label: method.type === "key" ? "Use a Zen API key" : "Sign in with your OpenCode account",
+    }))
+    return [
+      {
+        ...item,
+        name: "OpenCode",
+        methods: [...methods, ...goKeys],
+        connections: [...item.connections, ...credentialConnections(go)],
+      },
+    ]
+  })
+}
+
+// A merged row holds several integrations' credentials; each integration keeps its own active one (listed first).
+export function activeCredentialIDs(list: IntegrationInfo[], rowID: string) {
+  const members = rowID === "opencode" ? ["opencode", "opencode-go"] : [rowID]
+  return new Set(
+    list.flatMap((item) => (members.includes(item.id) ? credentialConnections(item).slice(0, 1) : [])).map((c) => c.id),
+  )
+}
+
 export function integrationOptions(list: IntegrationInfo[]) {
-  return list.toSorted(
+  return foldOpenCode(list).toSorted(
     (a, b) =>
       Number(b.metadata?.source === "mcp") - Number(a.metadata?.source === "mcp") ||
       (INTEGRATION_PRIORITY[a.id] ?? 99) - (INTEGRATION_PRIORITY[b.id] ?? 99) ||
@@ -186,13 +225,13 @@ function manageConnections(
     const [deleting, setDeleting] = createSignal<string>()
     const [selected, setSelected] = createSignal(methods.length ? "add" : credentialConnections(integration)[0]?.id)
     const current = createMemo(() =>
-      data.location.integration.list(location)?.find((item) => item.id === integration.id),
+      foldOpenCode(data.location.integration.list(location) ?? []).find((item) => item.id === integration.id),
     )
+    const active = createMemo(() => activeCredentialIDs(data.location.integration.list(location) ?? [], integration.id))
 
     return (
       <DialogSelect
         title={integration.name}
-        current={credentialConnections(current() ?? integration)[0]?.id}
         focusCurrent={false}
         preserveSelection
         onMove={(option) => {
@@ -218,6 +257,7 @@ function manageConnections(
                   ? `Press ${shortcuts.get("dialog.integration.delete")} again to confirm`
                   : connection.label,
                 value: connection.id,
+                current: active().has(connection.id),
                 footer: connection.status ? "Sign in required →" : undefined,
                 footerColor: connection.status ? theme.text.feedback.warning.base : undefined,
                 category: "Connected accounts",
@@ -227,7 +267,7 @@ function manageConnections(
                   if (connection.status?.url) return void openUrl(connection.status.url).catch(toast.error)
                   if (connection.status)
                     return selectMethod(current() ?? integration, methods, location, dialog, onConnected)
-                  if (credentialConnections(current() ?? integration)[0]?.id === connection.id) return
+                  if (active().has(connection.id)) return
                   void client.api.credential.activate({ credentialID: connection.id }).catch(toast.error)
                 },
               }
@@ -301,9 +341,10 @@ function selectMethod(
       <DialogSelect
         title={`Connect ${integration.name}`}
         renderFilter={!newDesigns()}
-        options={methods.map((method) => ({
+        options={methods.map((method, index) => ({
           title: method.type === "key" ? (method.label ?? "API key") : method.label,
-          value: method.type === "key" ? "key" : method.id,
+          // A merged row can offer several key methods, so the position keeps each value unique.
+          value: index,
           onSelect: () => openMethod(integration, method, location, dialog, onConnected),
         }))}
       />
@@ -312,12 +353,13 @@ function selectMethod(
 }
 
 function openMethod(
-  integration: IntegrationInfo,
+  row: IntegrationInfo,
   method: ConnectMethod,
   location: LocationRef,
   dialog: ReturnType<typeof useDialog>,
   onConnected?: OnIntegrationConnected,
 ) {
+  const integration = METHOD_OWNER.get(method) ?? row
   if (method.type === "key") {
     void beginKey(integration, method, location, dialog, onConnected)
     return
diff --git a/packages/tui/src/ui/dialog-select.tsx b/packages/tui/src/ui/dialog-select.tsx
index c298c8d40ce8..0b3e2e6afdce 100644
--- a/packages/tui/src/ui/dialog-select.tsx
+++ b/packages/tui/src/ui/dialog-select.tsx
@@ -113,6 +113,8 @@ export interface DialogSelectOption<T = any> {
   fg?: RGBA
   gutter?: (color: RGBA) => JSX.Element
   margin?: JSX.Element
+  /** Marks this option current instead of matching the list's `current`, for lists with several current options. */
+  current?: boolean
   /**
    * Shown below the list while this option is selected, under the "new-designs" experiment. A string is shown in muted
    * text. A function is called each time the option becomes selected, because a rendered element cannot be shown again
@@ -777,7 +779,7 @@ export function DialogSelect<T>(props: DialogSelectProps<T>) {
                   <For each={options}>
                     {(option) => {
                       const active = createMemo(() => !props.locked && isDeepEqual(option.value, selected()?.value))
-                      const current = createMemo(() => isDeepEqual(option.value, props.current))
+                      const current = createMemo(() => option.current ?? isDeepEqual(option.value, props.current))
                       return (
                         <box
                           flexDirection="column"
diff --git a/packages/tui/test/cli/cmd/tui/integration-options.test.ts b/packages/tui/test/cli/cmd/tui/integration-options.test.ts
index afb2ffc7d6e0..4f9de731b75c 100644
--- a/packages/tui/test/cli/cmd/tui/integration-options.test.ts
+++ b/packages/tui/test/cli/cmd/tui/integration-options.test.ts
@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test"
 import type { IntegrationInfo } from "@opencode/client"
 import {
+  activeCredentialIDs,
   connectionSummary,
   connectMethods,
   credentialConnections,
@@ -24,7 +25,35 @@ describe("integrationOptions", () => {
         integration({ id: "opencode", name: "OpenCode Zen" }),
         integration({ id: "opencode-go", name: "OpenCode Go" }),
       ]).map((item) => item.id),
-    ).toEqual(["opencode-go", "opencode", "openai", "anthropic", "mistral", "custom-z"])
+    ).toEqual(["opencode", "openai", "anthropic", "mistral", "custom-z"])
+  })
+
+  test("folds OpenCode Go into one OpenCode row with account sign-in and both API keys", () => {
+    const [row] = integrationOptions([
+      integration({
+        id: "opencode-go",
+        name: "OpenCode Go",
+        methods: [{ type: "key" }, { type: "env", names: ["OPENCODE_API_KEY"] }],
+        connections: [{ type: "credential", method: "key", id: "cred_go", label: "Go key" }],
+      }),
+      integration({
+        id: "opencode",
+        name: "OpenCode Console",
+        methods: [
+          { type: "key", label: "API key (service account)" },
+          { type: "oauth", id: "device", label: "OpenCode Console account" },
+        ],
+        connections: [{ type: "credential", method: "oauth", id: "cred_acme", label: "Acme" }],
+      }),
+    ])
+
+    expect(row.name).toBe("OpenCode")
+    expect(connectMethods(row).map((method) => method.label)).toEqual([
+      "Sign in with your OpenCode account",
+      "Use a Zen API key",
+      "Use a Go API key",
+    ])
+    expect(credentialConnections(row).map((connection) => connection.id)).toEqual(["cred_acme", "cred_go"])
   })
 
   test("keeps MCP integrations above popular integrations without relying on their IDs", () => {
@@ -36,7 +65,35 @@ describe("integrationOptions", () => {
         integration({ id: "opencode", name: "OpenCode Zen" }),
         integration({ id: "opencode-go", name: "OpenCode Go" }),
       ]).map((item) => item.id),
-    ).toEqual(["github", "linear", "opencode-go", "opencode", "openai"])
+    ).toEqual(["github", "linear", "opencode", "openai"])
+  })
+})
+
+describe("activeCredentialIDs", () => {
+  test("keeps one active credential per integration in the OpenCode row", () => {
+    const list = [
+      integration({
+        id: "opencode",
+        name: "OpenCode Console",
+        connections: [{ type: "credential", method: "oauth", id: "cred_acme", label: "Acme" }],
+      }),
+      integration({
+        id: "opencode-go",
+        name: "OpenCode Go",
+        connections: [
+          { type: "credential", method: "key", id: "cred_go2", label: "Go key 2" },
+          { type: "credential", method: "key", id: "cred_go1", label: "Go key 1" },
+        ],
+      }),
+      integration({
+        id: "openai",
+        name: "OpenAI",
+        connections: [{ type: "credential", method: "key", id: "cred_openai", label: "Work" }],
+      }),
+    ]
+
+    expect([...activeCredentialIDs(list, "opencode")]).toEqual(["cred_acme", "cred_go2"])
+    expect([...activeCredentialIDs(list, "openai")]).toEqual(["cred_openai"])
   })
 })
 
diff --git a/packages/tui/test/cli/tui/dialog-integration.test.tsx b/packages/tui/test/cli/tui/dialog-integration.test.tsx
index 744ec506f784..2bdd485ce1a2 100644
--- a/packages/tui/test/cli/tui/dialog-integration.test.tsx
+++ b/packages/tui/test/cli/tui/dialog-integration.test.tsx
@@ -247,6 +247,170 @@ test("uses the active location for integration data without scoping credential r
   }
 })
 
+test("shows one OpenCode row whose Go API key method connects OpenCode Go", async () => {
+  const fixture = await renderOpenCode()
+
+  try {
+    expect(fixture.app.captureCharFrame()).not.toContain("OpenCode Go")
+    expect(fixture.app.captureCharFrame()).not.toContain("OpenCode Console")
+
+    fixture.app.mockInput.pressEnter()
+    await fixture.app.waitForFrame((frame) => frame.includes("Connect OpenCode") && frame.includes("Use a Go API key"))
+    const frame = fixture.app.captureCharFrame()
+    expect(frame.indexOf("Sign in with your OpenCode account")).toBeLessThan(frame.indexOf("Use a Zen API key"))
+    expect(frame.indexOf("Use a Zen API key")).toBeLessThan(frame.indexOf("Use a Go API key"))
+
+    fixture.app.mockInput.pressArrow("down")
+    fixture.app.mockInput.pressArrow("down")
+    fixture.app.mockInput.pressEnter()
+    await fixture.app.waitFor(() => fixture.app.renderer.currentFocusedEditor instanceof TextareaRenderable)
+    await fixture.app.mockInput.typeText("go-key")
+    fixture.app.mockInput.pressEnter()
+    await fixture.app.waitFor(() => fixture.requests.length === 1)
+    expect(fixture.requests).toEqual([
+      { method: "POST", path: "/api/integration/opencode-go/connect/key", body: { key: "go-key" } },
+    ])
+  } finally {
+    fixture.app.renderer.destroy()
+  }
+})
+
+test("hovering the Go API key method selects it rather than the Zen key", async () => {
+  const fixture = await renderOpenCode()
+
+  try {
+    fixture.app.mockInput.pressEnter()
+    await fixture.app.waitForFrame((frame) => frame.includes("Use a Go API key"))
+    const lines = fixture.app.captureCharFrame().split("\n")
+    const row = lines.findIndex((line) => line.includes("Use a Go API key"))
+    await fixture.app.mockMouse.moveTo(lines[row]!.indexOf("Use a Go API key") + 1, row)
+    fixture.app.mockInput.pressEnter()
+    await fixture.app.waitFor(() => fixture.app.renderer.currentFocusedEditor instanceof TextareaRenderable)
+    await fixture.app.mockInput.typeText("go-key")
+    fixture.app.mockInput.pressEnter()
+    await fixture.app.waitFor(() => fixture.requests.length === 1)
+    expect(fixture.requests[0]?.path).toBe("/api/integration/opencode-go/connect/key")
+  } finally {
+    fixture.app.renderer.destroy()
+  }
+})
+
+test("marks the active Console account and the active Go key, and switching Go keys keeps the Console marker", async () => {
+  const fixture = await renderOpenCode({
+    opencode: [{ type: "credential", method: "oauth", id: "cred_acme", label: "Acme" }],
+    go: [
+      { type: "credential", method: "key", id: "cred_go1", label: "Go key 1" },
+      { type: "credential", method: "key", id: "cred_go2", label: "Go key 2" },
+    ],
+  })
+  const marked = (label: string) =>
+    fixture.app
+      .captureCharFrame()
+      .split("\n")
+      .find((line) => line.includes(label))
+      ?.includes("\u25cf")
+
+  try {
+    fixture.app.mockInput.pressEnter()
+    await fixture.app.waitForFrame((frame) => frame.includes("Connected accounts") && frame.includes("Go key 2"))
+    expect([marked("Acme"), marked("Go key 1"), marked("Go key 2")]).toEqual([true, true, false])
+
+    fixture.app.mockInput.pressArrow("down")
+    fixture.app.mockInput.pressArrow("down")
+    fixture.app.mockInput.pressArrow("down")
+    fixture.app.mockInput.pressEnter()
+    await fixture.app.waitFor(() => marked("Go key 2") === true)
+
+    expect(fixture.requests).toEqual([{ method: "POST", path: "/api/credential/cred_go2/activate" }])
+    expect([marked("Acme"), marked("Go key 1"), marked("Go key 2")]).toEqual([true, false, true])
+  } finally {
+    fixture.app.renderer.destroy()
+  }
+})
+
+type Credential = { type: "credential"; method: "key" | "oauth"; id: string; label: string }
+
+// /connect with OpenCode Console and OpenCode Go, which the dialog shows as one OpenCode row.
+async function renderOpenCode(accounts: { opencode?: Credential[]; go?: Credential[] } = {}) {
+  const events = createEventStream()
+  const requests: Array<{ method: string; path: string; body?: unknown }> = []
+  let go = accounts.go ?? []
+  const calls = createFetch(async (url, request) => {
+    const directory = decodeURIComponent(request.headers.get("x-opencode-directory") ?? process.cwd())
+    const location = { directory, project: { id: "proj_test", directory, canonical: directory } }
+    if (url.pathname === "/api/integration")
+      return json({
+        location,
+        data: [
+          { id: "opencode-go", name: "OpenCode Go", methods: [{ type: "key" }], connections: go },
+          {
+            id: "opencode",
+            name: "OpenCode Console",
+            methods: [
+              { type: "key", label: "API key (service account)" },
+              { type: "oauth", id: "device", label: "OpenCode Console account" },
+            ],
+            connections: accounts.opencode ?? [],
+          },
+        ],
+      })
+    if (request.method === "POST" && url.pathname.endsWith("/connect/key")) {
+      requests.push({ method: request.method, path: url.pathname, body: await request.json() })
+      return new Response(null, { status: 204 })
+    }
+    if (request.method === "POST" && /^\/api\/credential\/[^/]+\/activate$/.test(url.pathname)) {
+      const id = url.pathname.split("/")[3]
+      const next = go.find((account) => account.id === id)
+      if (next) go = [next, ...go.filter((account) => account.id !== id)]
+      requests.push({ method: request.method, path: url.pathname })
+      events.emit({
+        id: `evt_switched_${id}`,
+        created: Date.now(),
+        type: "credential.switched",
+        data: { integrationID: "opencode-go", credentialID: id },
+      })
+      return new Response(null, { status: 204 })
+    }
+    if (url.pathname === "/api/model" || url.pathname === "/api/provider") return json({ location, data: [] })
+    return undefined
+  }, events)
+
+  function Probe() {
+    const data = useData()
+    const dialog = useDialog()
+    onMount(() => void data.location.integration.sync().then(() => dialog.replace(() => <DialogIntegration />)))
+    return null
+  }
+
+  const app = await testRender(
+    () => (
+      <TestTuiContexts>
+        <ConfigProvider config={createTuiResolvedConfig()}>
+          <Keymap.Provider>
+            <ToastProvider>
+              <ClientProvider api={createApi(calls.fetch)}>
+                <DataProvider directory={process.cwd()}>
+                  <LocationProvider>
+                    <ThemeProvider mode="dark" source={emptyThemeSource}>
+                      <DialogProvider>
+                        <Probe />
+                      </DialogProvider>
+                    </ThemeProvider>
+                  </LocationProvider>
+                </DataProvider>
+              </ClientProvider>
+            </ToastProvider>
+          </Keymap.Provider>
+        </ConfigProvider>
+      </TestTuiContexts>
+    ),
+    { width: 100, height: 30, kittyKeyboard: true },
+  )
+  app.renderer.start()
+  await app.waitForFrame((frame) => frame.includes("OpenCode"))
+  return { app, requests }
+}
+
 async function renderIntegration(activeLocation?: LocationRef, form?: FormFields) {
   const events = createEventStream()
   const requests: Array<{ method: string; path: string; body?: unknown }> = []