@@ -111,7 +111,7 @@ altimate
 The URL must use HTTPS. Credentials,
 query strings, and fragments in the URL are rejected. `ALTIMATE_FREE_GATEWAY_URL` is retained as a
 legacy fallback, but `ALTIMATE_BASE_GATEWAY_URL` takes precedence. If the configured gateway host
-changes, credentials issued by the previous host are not loaded and the consented registration
+changes, credentials issued by the previous host are not loaded and the registration
 flow must run again.
 
 Altimate Base waits up to **5 minutes** for the gateway to send response headers, because the
 
@@ -76,6 +76,8 @@ export namespace Server {
   // because a cache built before a background registration finished cannot be told apart from one
   // built after it, in any directory or either registry.
   let appliedBaseCredential: string | undefined
+  // Serializes the register route's check-and-reload, so concurrent calls reload at most once.
+  let baseReloadQueue: Promise<unknown> = Promise.resolve()
   // altimate_change end
 
   export const Default = lazy(() => createApp({}))
@@ -781,15 +783,6 @@ export namespace Server {
             )
           }
 
-          // altimate_change — Codex review finding: `FreeTier.register()` returns success whether
-          // it minted/rotated a credential OR just found an existing valid one (the idempotent
-          // fast path — see its "already registered" branch in free/client.ts). Everything below
-          // is instance-wide teardown that only matters when the credential on disk actually
-          // changed; comparing it before/after `gate.register()` (rather than changing
-          // `register()`'s own return shape, which every other caller — the picker, and a dozen
-          // existing tests — depends on as a plain `Credentials`) reports that without touching
-          // that contract.
-          const before = await FreeTier.credentials().catch(() => undefined)
           const gate = FreeTierConsent.createRegistrationGate({
             register: () => FreeTier.register({ origin: "server" }),
             onUnexpectedError: (error) => log.error("Altimate Base registration failed", { error }),
@@ -815,45 +808,47 @@ export namespace Server {
           // A failure in either leaves the credential written but provider lists possibly stale, so
           // it is reported rather than swallowed: the client needs to know its picker may be wrong.
           //
-          // Skipped entirely when nothing changed: an idempotent register (already valid
-          // credentials for this gateway) has nothing for a provider loader to re-read, so tearing
-          // down every session, LSP, PTY, MCP connection and file watcher in the process would be
-          // pure disruption for zero benefit.
+          // Skipped when this process has already reloaded for the credential now on disk: an
+          // idempotent register (the "already registered" fast path) then has nothing for a
+          // provider loader to re-read, and tearing down every session, LSP, PTY, MCP connection
+          // and file watcher again would be pure disruption. An unchanged file alone is not enough:
+          // a startup registration that finished in the background leaves caches built before it
+          // without Base, in any directory and in either registry.
+          //
+          // The check and the reload run one at a time, so two concurrent calls cannot both pass
+          // the check and dispose the same live resources twice; the second sees the first's mark.
           if (outcome.ok) {
-            const after = await FreeTier.credentials().catch(() => undefined)
-            // Identity covers everything that decides whether a loader sees Base: an expired or
-            // rejected credential loads as absent, and a logout elsewhere rotates the nonce, so the
-            // same key and URL reissued after either still has to reload.
-            const identity = (value: typeof after) =>
-              value
-                ? [value.baseURL, value.apiKey, value.expiresAt ?? "", value.rejected ? "rejected" : "", value.logoutNonce ?? ""].join("\n")
+            const reload = baseReloadQueue.then(async () => {
+              const current = await FreeTier.credentials().catch(() => undefined)
+              // Identity covers everything that decides whether a loader sees Base: an expired or
+              // rejected credential loads as absent, and a logout elsewhere rotates the nonce, so the
+              // same key and URL reissued after either still has to reload.
+              const fingerprint = current
+                ? [current.baseURL, current.apiKey, current.expiresAt ?? "", current.rejected ? "rejected" : "", current.logoutNonce ?? ""].join("\n")
                 : undefined
-            const fingerprint = identity(after)
-            const changed = identity(before) !== fingerprint
-            // An unchanged file is not enough to skip: a startup registration that finished in the
-            // background leaves caches built before it without Base, in any directory and in either
-            // registry. Skip only when this process has already reloaded for this exact credential.
-            if (!changed && fingerprint !== undefined && fingerprint === appliedBaseCredential) {
-              return c.json(outcome)
-            }
-            const disposed = await Promise.all([
-              Instance.disposeAll().then(
-                () => true,
-                (error) => {
-                  log.error("Altimate Base registered but legacy instance disposal failed", { error })
-                  return false
-                },
-              ),
-              AppRuntime.runPromise(InstanceStore.Service.use((store) => store.disposeAll())).then(
-                () => true,
-                (error) => {
-                  log.error("Altimate Base registered but InstanceStore disposal failed", { error })
-                  return false
-                },
-              ),
-            ]).then((results) => results.every(Boolean))
-            if (disposed) appliedBaseCredential = fingerprint
-            return c.json(disposed ? outcome : { ...outcome, staleProviders: true as const })
+              if (fingerprint !== undefined && fingerprint === appliedBaseCredential) return true
+              const disposed = await Promise.all([
+                Instance.disposeAll().then(
+                  () => true,
+                  (error) => {
+                    log.error("Altimate Base registered but legacy instance disposal failed", { error })
+                    return false
+                  },
+                ),
+                AppRuntime.runPromise(InstanceStore.Service.use((store) => store.disposeAll())).then(
+                  () => true,
+                  (error) => {
+                    log.error("Altimate Base registered but InstanceStore disposal failed", { error })
+                    return false
+                  },
+                ),
+              ]).then((results) => results.every(Boolean))
+              if (disposed) appliedBaseCredential = fingerprint
+              return disposed
+            })
+            baseReloadQueue = reload.catch(() => undefined)
+            const reloaded = await reload
+            return c.json(reloaded ? outcome : { ...outcome, staleProviders: true as const })
           }
           return c.json(outcome)
         },
 
@@ -402,6 +402,34 @@ describe("ACP service sessions", () => {
     })
   })
 
+  // altimate_change start — the cases above all resolve to Base, so they cannot tell a fresh
+  // re-read from a reused first selection; this one changes the answer between sessions.
+  it("re-reads a recent pick that changes between sessions in a cached directory", async () => {
+    const base = {
+      ...provider,
+      id: ProviderID.make("altimate-free"),
+      models: {
+        [ModelID.make("altimate-base")]: {
+          ...provider.models[modelID],
+          id: ModelID.make("altimate-base"),
+          providerID: ProviderID.make("altimate-free"),
+        },
+      },
+    } satisfies Provider.Info
+    await withTestStateHome(async () => {
+      const stateFile = path.join(Global.Path.state, "model.json")
+      await fs.writeFile(stateFile, JSON.stringify({ recent: [{ providerID: "altimate-free", modelID: "altimate-base" }] }))
+      const { service } = makeService([], { providers: [provider, base] })
+      const first = await Effect.runPromise(service.newSession({ cwd: "/workspace", mcpServers: [] }))
+      expect(select(first, "model")?.currentValue).toBe("altimate-free/altimate-base")
+
+      await fs.writeFile(stateFile, JSON.stringify({ recent: [{ providerID, modelID }] }))
+      const second = await Effect.runPromise(service.newSession({ cwd: "/workspace", mcpServers: [] }))
+      expect(select(second, "model")?.currentValue).toBe(`${providerID}/${modelID}`)
+    })
+  })
+  // altimate_change end
+
   it("fails before creating a session when the configured model is unavailable", async () => {
     const bigPickleProvider = {
       ...provider,
 
@@ -99,18 +99,6 @@ describe("FreeTier.autoRegister", () => {
     expect(gateway.registerCalls).toHaveLength(0)
   })
 
-  test("a logout that lands before the registration lock is acquired is not missed", async () => {
-    // Simulates the race the spec calls out: nothing has registered yet (no pre-existing
-    // credential), and a logout call — which takes the SAME lock — completes before autoRegister's
-    // own lock body runs. Because that body reads the store fresh from inside the lock (no
-    // pre-lock "expected" value carried in), it sees the logout unconditionally.
-    await FreeTierStore.remove()
-    await FreeTier.logout()
-    const result = await FreeTier.autoRegister()
-    expect(result).toEqual({ status: "skipped", reason: "logged-out" })
-    expect(gateway.registerCalls).toHaveLength(0)
-  })
-
   test("is skipped when no gateway URL is configured, with no network call", async () => {
     delete process.env.ALTIMATE_BASE_GATEWAY_URL
     delete process.env.ALTIMATE_FREE_GATEWAY_URL
@@ -199,6 +187,7 @@ describe("FreeTier.autoRegisterWithin", () => {
       const registered = await waitFor(() => FreeTier.isRegistered(), (v) => v === true)
       expect(registered).toBe(true)
     } finally {
+      resolveRequest()
       slow.mockRestore()
     }
   })
 
@@ -57,7 +57,7 @@ afterEach(() => {
   gateway.restore()
 })
 
-/** Registers a real credential through the production consent path against the fake gateway. */
+/** Registers a real credential through the real `/register` path against the fake gateway. */
 async function registerCredential(): Promise<void> {
   gateway.registerNext({ kind: "ok" })
   await FreeTier.register({ origin: "picker" })
 
@@ -464,6 +464,7 @@ describe("ProviderError.parseAPICallError: Altimate Base isolation", () => {
       providerID: "altimate-free" as any,
       error: rateLimited("throttling_error", "", { "retry-after": "12" }),
     })
+    expect(result.type).toBe("api_error")
     if (result.type === "api_error") {
       expect(result.responseHeaders?.["retry-after"]).toBe("12")
     }
@@ -526,6 +527,8 @@ describe("ProviderError.parseAPICallError: Altimate Base isolation", () => {
         "retry-after": "900",
       }),
     })
+    expect(result.type).toBe("api_error")
+    expect(result.message).toContain("Altimate Base has reached its shared daily limit")
     if (result.type === "api_error") {
       expect(result.isRetryable).toBe(false)
       expect(result.responseHeaders?.["retry-after"]).toBe("900")
 
@@ -136,7 +136,7 @@ describe("Altimate Base registration route", () => {
   // idempotent path is pure disruption for zero benefit, since no provider loader has anything new
   // to re-read.
   test("disposes every instance when registration actually mints a new credential", async () => {
-    mockCredentialsSequence(undefined, { apiKey: "sk-new", baseURL: "https://gateway.test", installSecret: "s" })
+    mockCredentialsSequence({ apiKey: "sk-new", baseURL: "https://gateway.test", installSecret: "s" })
     mockRegister(async () => ({ apiKey: "sk-new", baseURL: "https://gateway.test", installSecret: "s" }))
     const disposeAll = spyOn(Instance, "disposeAll")
     try {
@@ -196,7 +196,7 @@ describe("Altimate Base registration route", () => {
       expect(disposeAll).toHaveBeenCalledTimes(1)
       credentialsSpy?.mockRestore()
       registerSpy?.mockRestore()
-      mockCredentialsSequence(expired, renewed)
+      mockCredentialsSequence(renewed)
       mockRegister(async () => renewed)
       expect(await (await post()).json()).toMatchObject({ ok: true })
       expect(disposeAll).toHaveBeenCalledTimes(2)
@@ -233,6 +233,38 @@ describe("Altimate Base registration route", () => {
     }
   })
 
+  test("two concurrent register calls reload once", async () => {
+    const shared = { apiKey: "sk-concurrent", baseURL: "https://gateway.test", installSecret: "s" }
+    mockCredentialsSequence(shared)
+    mockRegister(async () => shared)
+    let release!: () => void
+    const held = new Promise<void>((resolve) => {
+      release = resolve
+    })
+    // Hold the first disposal open so the second request arrives while it is still in flight.
+    const disposeAll = spyOn(Instance, "disposeAll").mockImplementation(async () => {
+      await held
+    })
+    const post = () =>
+      app().request("/altimate/base/register", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({}),
+      })
+    try {
+      const first = post()
+      const second = post()
+      await Bun.sleep(50)
+      release()
+      const bodies = await Promise.all([first, second].map(async (r) => (await r).json()))
+      for (const body of bodies) expect(body).toMatchObject({ ok: true })
+      expect(disposeAll).toHaveBeenCalledTimes(1)
+    } finally {
+      release()
+      disposeAll.mockRestore()
+    }
+  })
+
   test("reloads for a credential registered in the background, even if one directory already sees Base", async () => {
     // A startup auto-registration that finished after the server started leaves the file unchanged
     // across this request, while caches built earlier (another directory, or the /api registry)
 
@@ -288,7 +288,9 @@ test("outside a first run the picker records an impression but not a choice", as
 // first-run welcome picker — the one shown to users with no model at all — a failed Base
 // registration then bricked Enter, `/` and mouse-up for the rest of the dialog session. Confirms
 // the fix: the same row can be retried after a failure, and the register attempt actually re-fires.
-test("a failed Altimate Base selection on the welcome picker can be retried", async () => {
+// It covers the re-fire only: the mocked `/provider` never lists Base's model, so the second
+// attempt cannot complete a selection here (selectAltimateBase's success path is tested directly).
+test("a failed Altimate Base selection on the welcome picker re-fires registration when retried", async () => {
   const picker = await mountPicker("first_run", [...ALL_PROVIDER_IDS, "altimate-free"], {
     registerOutcomes: ["error", "ok"],
   })
 
@@ -42,7 +42,7 @@ const baseProvider = { id: "altimate-free", name: "Altimate", models: { "altimat
 
 async function mount(options: { preSeedShown: boolean }) {
   const [
-    { KVProvider },
+    { KVProvider, useKV },
     { LocalProvider, useLocal },
     { ArgsProvider },
     { ThemeProvider },
@@ -87,10 +87,12 @@ async function mount(options: { preSeedShown: boolean }) {
 
   let localAccessor: ReturnType<typeof useLocal> | undefined
   let toastAccessor: ReturnType<typeof useToast> | undefined
+  let kvAccessor: ReturnType<typeof useKV> | undefined
   const shownMessages: string[] = []
   function Probe() {
     localAccessor = useLocal()
     toastAccessor = useToast()
+    kvAccessor = useKV()
     useAltimateBaseDisclosureNotice()
     createEffect(() => {
       const message = toastAccessor?.currentToast?.message
@@ -139,6 +141,8 @@ async function mount(options: { preSeedShown: boolean }) {
     },
     async cleanup() {
       app.renderer.destroy()
+      // Let the notice's "shown" write land before its state directory is removed.
+      await kvAccessor?.flush()
       await tmp[Symbol.asyncDispose]()
     },
   }
 
@@ -160,16 +160,16 @@ describe("selectAltimateBase", () => {
     const calls: string[] = []
     const fakes = fakeCollaborators({
       registerAltimateBase: undefined,
-      fetchImpl: (async (input: RequestInfo | URL) => {
-        calls.push(String(input))
+      fetchImpl: (async (input: RequestInfo | URL, init?: RequestInit) => {
+        calls.push(`${init?.method} ${String(input)} ${String(init?.body)}`)
         return Response.json({ ok: true })
       }) as typeof fetch,
     })
 
     const result = await selectAltimateBase(fakes)
 
     expect(result).toBe(true)
-    expect(calls).toEqual(["http://test/altimate/base/register"])
+    expect(calls).toEqual(["POST http://test/altimate/base/register {}"])
     expect(fakes.modelSetCalls).toHaveLength(1)
     expect(fakes.dialogReplaceCount).toBe(0)
   })