@@ -440,7 +440,9 @@ const REGISTER_FAILURE_MESSAGE = "Could not set up Altimate Base. Try again, or
  * context/sdk.tsx) when available. An attached TUI has no in-process worker to call
  * (cli/cmd/attach.ts never provides it), so it falls back to the server's own
  * `POST /altimate/base/register` route over the same transport (`sdk.fetch`/`sdk.url`) everything
- * else uses.
+ * else uses — including `sdk.headers`, the same Basic-auth headers `createOpencodeClient` bakes
+ * into every typed SDK call, so this raw fetch doesn't 401 against a password-protected attached
+ * server the way a bare `sdk.fetch` call would.
  */
 async function registerAltimateBase(sdk: ReturnType<typeof useSDK>): Promise<RegisterOutcome> {
   try {
@@ -449,9 +451,11 @@ async function registerAltimateBase(sdk: ReturnType<typeof useSDK>): Promise<Reg
       if (data.ok) return { ok: true }
       return { ok: false, result: data.result, message: data.message || REGISTER_FAILURE_MESSAGE }
     }
+    const headers = new Headers(sdk.headers)
+    headers.set("Content-Type", "application/json")
     const response = await sdk.fetch(`${sdk.url}/altimate/base/register`, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
+      headers,
       body: JSON.stringify({}),
     })
     const body = (await response.json().catch(() => undefined)) as
@@ -494,6 +498,12 @@ export function useAltimateBaseDisclosureNotice() {
  * the provider dialog): register if needed, refresh provider state, confirm the model actually
  * came up, then select it. An error at any step is shown via toast and the selection is left
  * alone — never a partial/failed switch.
+ *
+ * Also guards against the originating picker going away mid-flight (see `stillOpen()` below):
+ * registration and bootstrap are both async, and if the user dismissed the picker or opened
+ * something else in the meantime, neither the model switch nor `dialog.clear()` should run —
+ * `clear()` would otherwise close whatever the user has open NOW, not the picker that started
+ * this.
  */
 export async function selectAltimateBase(input: {
   sdk: ReturnType<typeof useSDK>
@@ -502,14 +512,27 @@ export async function selectAltimateBase(input: {
   toast: ReturnType<typeof useToast>
   dialog: ReturnType<typeof useDialog>
 }): Promise<boolean> {
+  // altimate_change start — Codex review finding: snapshot the top-of-stack item BY REFERENCE at
+  // entry; `stillOpen()` re-checks it after every await below. `dialog.replace()`/`clear()` always
+  // install a brand-new stack (and a dismissal empties it), so any of those happening in between —
+  // whether the user backed out or a different feature took the dialog stack over — makes this
+  // reference comparison false, and every call site below bails out silently: no toast (there is
+  // nothing left for it to be about), no model switch, no `clear()`.
+  const originatingDialog = input.dialog.stack.at(-1)
+  const stillOpen = () => input.dialog.stack.at(-1) === originatingDialog
+  // altimate_change end
+
   const outcome = await registerAltimateBase(input.sdk)
+  if (!stillOpen()) return false
   if (!outcome.ok) {
     input.toast.show({ variant: "error", message: outcome.message })
     return false
   }
 
   await input.sdk.client.instance.dispose().catch(() => {})
+  if (!stillOpen()) return false
   await input.sync.bootstrap().catch(() => {})
+  if (!stillOpen()) return false
   const available = input.sync.data.provider.some(
     (provider) => provider.id === "altimate-free" && Boolean(provider.models?.["altimate-base"]),
   )
 
@@ -365,14 +365,6 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
       return !!provider?.models[model.modelID]
     }
 
-    function getFirstValidModel(...modelFns: (() => { providerID: string; modelID: string } | undefined)[]) {
-      for (const modelFn of modelFns) {
-        const model = modelFn()
-        if (!model) continue
-        if (isModelValid(model)) return model
-      }
-    }
-
     function createAgent() {
       const agents = createMemo(() => sync.data.agent.filter((agent) => agent.mode !== "subagent" && !agent.hidden))
       const visibleAgents = createMemo(() => sync.data.agent.filter((agent) => !agent.hidden))
@@ -598,26 +590,29 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
       }
       // altimate_change end
 
-      const fallbackModel = createMemo(() => {
+      // altimate_change start — Codex review finding: `currentModel()` below used to apply the
+      // stale-Zen -> Base substitution uniformly to whatever `fallbackModel()` returned, but
+      // `fallbackModel()` returns an EXPLICIT `--model`/config `model` pick verbatim when either is
+      // set (below) — so an explicit ask for the now-broken public Zen tier was silently rewritten
+      // to Base instead of surfacing as broken. Mirrors just those two explicit checks (not
+      // `fallbackModel()`'s recents/allowlist implicit tail) so `currentModel()` can tell them apart
+      // without duplicating `fallbackModel()`'s own logic inline.
+      const explicitFallbackModel = createMemo(() => {
         if (args.model) {
           const { providerID, modelID } = parseModel(args.model)
-          if (isModelValid({ providerID, modelID })) {
-            return {
-              providerID,
-              modelID,
-            }
-          }
+          if (isModelValid({ providerID, modelID })) return { providerID, modelID }
         }
-
         if (sync.data.config.model) {
           const { providerID, modelID } = parseModel(sync.data.config.model)
-          if (isModelValid({ providerID, modelID })) {
-            return {
-              providerID,
-              modelID,
-            }
-          }
+          if (isModelValid({ providerID, modelID })) return { providerID, modelID }
         }
+        return undefined
+      })
+      // altimate_change end
+
+      const fallbackModel = createMemo(() => {
+        const explicit = explicitFallbackModel() // altimate_change — see its declaration above
+        if (explicit) return explicit
 
         // altimate_change start — Base is excluded only by an actual enabled_providers/disabled_providers
         // verdict, which `sync.data.provider` (server-built) already reflects. The mere presence of
@@ -678,21 +673,35 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
       // be a stale keyless public-Zen pick; replace it with registered Base the same way
       // `fallbackModel()`'s recents loop does, rather than replaying a model OpenCode Zen now
       // rejects outright. A credentialed/paid selection is untouched.
+      //
+      // Codex review finding: that substitution must only ever reach an IMPLICIT pick — the
+      // persisted per-agent selection below, or `fallbackModel()`'s own implicit recents/allowlist
+      // tail — never something explicitly asked for: an agent's own configured `model` field, or
+      // `--model`/config `model` (see `explicitFallbackModel` above `fallbackModel()`). Each
+      // candidate is checked in the SAME priority order this memo used before; only the two
+      // implicit branches route through `substituteStaleZen`.
+      function substituteStaleZen(model: { providerID: string; modelID: string } | undefined) {
+        if (!model) return model
+        const provider = sync.data.provider.find((candidate) => candidate.id === model.providerID)
+        if (provider && isPublicZenProvider(provider) && isModelValid(ALTIMATE_BASE_MODEL)) {
+          return { ...ALTIMATE_BASE_MODEL }
+        }
+        return model
+      }
+
       const currentModel = createMemo(() => {
         const a = agent.current()
-        const resolved =
-          getFirstValidModel(
-            () => a && modelStore.model[a.name],
-            () => a && a.model,
-            fallbackModel,
-          ) ?? undefined
-        if (resolved) {
-          const provider = sync.data.provider.find((candidate) => candidate.id === resolved.providerID)
-          if (provider && isPublicZenProvider(provider) && isModelValid(ALTIMATE_BASE_MODEL)) {
-            return { ...ALTIMATE_BASE_MODEL }
-          }
-        }
-        return resolved
+
+        const persistedAgentPick = a ? modelStore.model[a.name] : undefined
+        if (persistedAgentPick && isModelValid(persistedAgentPick)) return substituteStaleZen(persistedAgentPick)
+
+        const agentConfiguredModel = a?.model
+        if (agentConfiguredModel && isModelValid(agentConfiguredModel)) return agentConfiguredModel
+
+        const explicit = explicitFallbackModel()
+        if (explicit) return explicit
+
+        return substituteStaleZen(fallbackModel())
       })
       // altimate_change end
 
 
@@ -208,6 +208,12 @@ export const { use: useSDK, provider: SDKProvider } = createSimpleContext({
       event: emitter,
       fetch: props.fetch ?? fetch,
       url: props.url,
+      // altimate_change — the auth headers `createOpencodeClient` above bakes into every typed SDK
+      // call (Basic auth for an attached, password-protected server — see cli/cmd/attach.ts). A raw
+      // `sdk.fetch` call bypasses the client entirely, so a caller hitting an untyped route
+      // directly (component/altimate-onboarding.tsx's `registerAltimateBase` HTTP fallback) needs
+      // these to attach them itself, or it 401s against a password-protected server.
+      headers: props.headers,
       registerAltimateBase: props.registerAltimateBase, // altimate_change — see the declaration above
     }
   },
 
@@ -5,13 +5,25 @@
 // this same file), so testing it here covers every call site's outcome without needing an `agent`
 // in the render harness (selectModel()'s underlying local.model.set() is agent-scoped, which the
 // component-mount fixtures used elsewhere in this package don't set up).
-import { describe, expect, test } from "bun:test"
+import { afterEach, describe, expect, test } from "bun:test"
 import type { useSDK } from "../../src/context/sdk"
 import type { useSync } from "../../src/context/sync"
 import type { useLocal } from "../../src/context/local"
 import type { useToast } from "../../src/ui/toast"
 import type { useDialog } from "../../src/ui/dialog"
-import { selectAltimateBase } from "../../src/component/altimate-onboarding"
+import { selectAltimateBase, resetSetupComplete } from "../../src/component/altimate-onboarding"
+
+// altimate_change start — Codex/CodeRabbit review finding: `selectAltimateBase()` calls
+// `markSetupComplete()` on every successful path, which flips the module-global `setupComplete`
+// solid-js signal declared in altimate-onboarding.tsx. That signal is shared with
+// `test/context/local.test.ts` (imported there too, and reset around every `markSetupComplete()`
+// call it makes) and read by every other suite through `useReady()`/`useSetupComplete()` — Bun's
+// test runner shares one module registry across every test file in the run, so a test here left
+// it `true` for whichever suite runs next. Restoring it here mirrors local.test.ts's own pattern.
+afterEach(() => {
+  resetSetupComplete()
+})
+// altimate_change end
 
 function fakeCollaborators(options: {
   registerAltimateBase?: () => Promise<{ ok: true } | { ok: false; result: "network" | "error"; message: string }>
@@ -20,6 +32,9 @@ function fakeCollaborators(options: {
    *  "the credential was minted, but the catalogue hasn't caught up yet" edge case sets this to
    *  false. */
   becomesAvailableAfterBootstrap?: boolean
+  // altimate_change — the Basic-auth headers an attached, password-protected server needs (see
+  // cli/cmd/attach.ts + context/sdk.tsx's `headers`).
+  headers?: RequestInit["headers"]
 }) {
   const modelSetCalls: unknown[] = []
   let dialogClearCount = 0
@@ -30,6 +45,14 @@ function fakeCollaborators(options: {
   const becomesAvailable = options.becomesAvailableAfterBootstrap ?? true
   const providerState: { id: string; models: Record<string, unknown> }[] = []
 
+  // altimate_change start — Codex review finding: `selectAltimateBase()`'s liveness guard compares
+  // `dialog.stack.at(-1)` by reference before and after each await. The fake stack starts as a
+  // single "the originating picker" item; `simulateDismiss()`/`simulateReplace()` let a test swap
+  // it out mid-flight, exactly as a real Escape/backdrop dismissal or an unrelated feature taking
+  // over the dialog stack would.
+  let stack: { readonly id: string }[] = [{ id: "originating-picker" }]
+  // altimate_change end
+
   const sdk = {
     client: {
       instance: {
@@ -40,6 +63,7 @@ function fakeCollaborators(options: {
     },
     fetch: options.fetchImpl ?? (async () => new Response("should not be called", { status: 500 })),
     url: "http://test",
+    headers: options.headers, // altimate_change — see the option's declaration above
     registerAltimateBase: options.registerAltimateBase,
   } as unknown as ReturnType<typeof useSDK>
 
@@ -70,11 +94,17 @@ function fakeCollaborators(options: {
   const dialog = {
     clear: () => {
       dialogClearCount++
+      stack = [] // altimate_change — mirrors the real clearAll()'s empty stack
     },
     replace: (..._args: unknown[]) => {
       dialogReplaceCount++
+      stack = [{ id: "replaced" }] // altimate_change — mirrors the real replace()'s new sole item
       return true
     },
+    get stack() {
+      // altimate_change — see `stack`'s declaration above
+      return stack
+    },
   } as unknown as ReturnType<typeof useDialog>
 
   return {
@@ -97,6 +127,14 @@ function fakeCollaborators(options: {
     get dialogReplaceCount() {
       return dialogReplaceCount
     },
+    // altimate_change start — see `stack`'s declaration above
+    simulateDismiss() {
+      stack = []
+    },
+    simulateReplace() {
+      stack = [{ id: "something-else" }]
+    },
+    // altimate_change end
   }
 }
 
@@ -136,6 +174,29 @@ describe("selectAltimateBase", () => {
     expect(fakes.dialogReplaceCount).toBe(0)
   })
 
+  // altimate_change start — Codex review finding: the HTTP fallback used a bare `sdk.fetch` call
+  // with no auth headers, so it 401ed against an attached, password-protected server (`opencode
+  // attach` — cli/cmd/attach.ts) even though `sdk.headers` (the same Basic-auth headers
+  // `createOpencodeClient` bakes into every typed SDK call) was one merge away.
+  test("an attached TUI's HTTP fallback sends the SDK's auth headers", async () => {
+    let seenHeaders: Headers | undefined
+    const fakes = fakeCollaborators({
+      registerAltimateBase: undefined,
+      headers: { Authorization: "Basic dGVzdDpwYXNz" },
+      fetchImpl: (async (_input: RequestInfo | URL, init?: RequestInit) => {
+        seenHeaders = new Headers(init?.headers)
+        return Response.json({ ok: true })
+      }) as typeof fetch,
+    })
+
+    const result = await selectAltimateBase(fakes)
+
+    expect(result).toBe(true)
+    expect(seenHeaders?.get("Authorization")).toBe("Basic dGVzdDpwYXNz")
+    expect(seenHeaders?.get("Content-Type")).toBe("application/json")
+  })
+  // altimate_change end
+
   test("a registration failure shows the toast and leaves the model unchanged", async () => {
     const fakes = fakeCollaborators({
       registerAltimateBase: async () => ({ ok: false, result: "network", message: "offline" }),
@@ -169,5 +230,50 @@ describe("selectAltimateBase", () => {
     expect(fakes.modelSetCalls).toHaveLength(0)
     expect(fakes.dialogClearCount).toBe(0)
   })
+
+  // altimate_change start — Codex review finding: registration and bootstrap are both async;
+  // if the originating picker went away (dismissed, or replaced by something else) while either
+  // was in flight, `selectAltimateBase()` must not select the model or call `dialog.clear()` —
+  // that `clear()` would close whatever the user has open NOW, not the picker that started this.
+  test("does not select the model or clear the dialog if the picker was dismissed while registration was in flight", async () => {
+    const fakes = fakeCollaborators({
+      registerAltimateBase: async () => {
+        // The user pressed Escape while this await was pending.
+        fakes.simulateDismiss()
+        return { ok: true }
+      },
+    })
+
+    const result = await selectAltimateBase(fakes)
+
+    expect(result).toBe(false)
+    expect(fakes.modelSetCalls).toHaveLength(0)
+    expect(fakes.dialogClearCount).toBe(0)
+    expect(fakes.disposed).toBe(false)
+    expect(fakes.bootstrapped).toBe(false)
+    expect(fakes.toastCalls).toHaveLength(0)
+  })
+
+  test("does not select the model or clear the dialog if something else replaced the dialog during bootstrap", async () => {
+    const fakes = fakeCollaborators({
+      registerAltimateBase: async () => ({ ok: true }),
+    })
+    const realBootstrap = fakes.sync.bootstrap
+    fakes.sync.bootstrap = async () => {
+      const result = await realBootstrap()
+      // A different feature (e.g. the command palette) took over the dialog stack while this
+      // await was pending.
+      fakes.simulateReplace()
+      return result
+    }
+
+    const result = await selectAltimateBase(fakes)
+
+    expect(result).toBe(false)
+    expect(fakes.modelSetCalls).toHaveLength(0)
+    expect(fakes.dialogClearCount).toBe(0)
+    expect(fakes.toastCalls).toHaveLength(0)
+  })
+  // altimate_change end
 })
 // altimate_change end