From 530c876b97c606507aad1fb28273cbedb47125d2 Mon Sep 17 00:00:00 2001
From: Peter Dave Hello <hsu@peterdavehello.org>
Date: Sat, 17 Oct 2026 00:17:43 +0800
Subject: [PATCH] Memoize getUserConfig to avoid repeated storage reads

Cache config per context and share concurrent reads. Return independent
deep copies with cloneDeep for older Safari, invalidate on settings and
locale changes, and exclude conversation history writes.

Read fresh settings at action and request boundaries, and pass the same
snapshot through ChatGPT Web requests and cleanup. Prevent older reads
from replacing newer cache entries, and retry failed migrations. Keep
Escape and Go Back failures contained so the actions remain retryable.

Keep useConfig's existing storage.local.onChanged listener unchanged;
its browser compatibility remains a separate follow-up.
---
 src/background/index.mjs                      |   9 +-
 src/background/menus.mjs                      |   9 +-
 src/components/ConversationCard/index.jsx     |  12 +-
 .../WebJumpBackNotification/index.jsx         |  16 +-
 src/config/index.mjs                          | 174 +++++++--
 src/config/language.mjs                       |   6 +-
 src/config/storage-keys.mjs                   |  19 +
 src/content-script/index.jsx                  |  46 ++-
 src/content-script/menu-tools/index.mjs       |   2 +-
 src/content-script/selection-tools/index.mjs  |   7 +-
 src/hooks/config-storage-listener.mjs         |   9 +-
 src/services/apis/chatgpt-web.mjs             |  95 +++--
 src/services/local-session.mjs                |   6 +-
 src/services/wrappers.mjs                     |  32 +-
 tests/setup/browser-shim.mjs                  | 112 +++++-
 tests/setup/chatgpt-web-loader-hooks.mjs      |  10 +
 ...-script-selection-toolbar-loader-hooks.mjs |  10 +-
 ...nversation-card-lifecycle-loader-hooks.mjs |   3 +-
 tests/setup/menu-loader-hooks.mjs             |  10 +
 tests/setup/web-jump-back-loader-hooks.mjs    |  47 +++
 tests/unit/background/menus.test.mjs          |  43 +++
 .../conversation-card-lifecycle.test.mjs      | 102 ++++++
 .../web-jump-back-notification.test.mjs       | 147 ++++++++
 tests/unit/config/language-config.test.mjs    |   8 +
 tests/unit/config/user-config-cache.test.mjs  | 329 ++++++++++++++++++
 .../config/user-config-cross-context.test.mjs | 233 +++++++++++++
 .../user-config-set-invalidation.test.mjs     |  22 ++
 tests/unit/content-script/menu-tools.test.mjs |  24 ++
 .../selection-toolbar-lifecycle.test.mjs      |  58 +--
 .../content-script/selection-tools.test.mjs   |  24 ++
 .../services/apis/chatgpt-web-config.test.mjs | 120 +++++++
 .../unit/services/wrappers-register.test.mjs  |  50 +++
 tests/unit/setup/browser-shim.test.mjs        |  98 ++++++
 33 files changed, 1744 insertions(+), 148 deletions(-)
 create mode 100644 src/config/storage-keys.mjs
 create mode 100644 tests/setup/chatgpt-web-loader-hooks.mjs
 create mode 100644 tests/setup/menu-loader-hooks.mjs
 create mode 100644 tests/setup/web-jump-back-loader-hooks.mjs
 create mode 100644 tests/unit/background/menus.test.mjs
 create mode 100644 tests/unit/components/web-jump-back-notification.test.mjs
 create mode 100644 tests/unit/config/user-config-cache.test.mjs
 create mode 100644 tests/unit/config/user-config-cross-context.test.mjs
 create mode 100644 tests/unit/config/user-config-set-invalidation.test.mjs
 create mode 100644 tests/unit/services/apis/chatgpt-web-config.test.mjs

diff --git a/src/background/index.mjs b/src/background/index.mjs
index 79b4f0c0d..a91b13e79 100644
--- a/src/background/index.mjs
+++ b/src/background/index.mjs
@@ -546,7 +546,7 @@ async function executeApi(
           console.debug('[background] Skipping a superseded direct ChatGPT Web session request.')
           return
         }
-        await generateAnswersWithChatgptWebApi(port, session.question, session, accessToken)
+        await generateAnswersWithChatgptWebApi(port, session.question, session, accessToken, config)
       }
     } else if (isUsingClaudeWebModel(session)) {
       console.debug('[background] Using Claude Web Model')
@@ -656,7 +656,7 @@ Browser.runtime.onMessage.addListener(async (message, sender) => {
         break
       case 'OPEN_CHAT_WINDOW': {
         console.log('[background] Processing OPEN_CHAT_WINDOW message')
-        const config = await getUserConfig()
+        const config = await getUserConfig({ fresh: true })
         const url = Browser.runtime.getURL('IndependentPanel.html')
         const tabs = await Browser.tabs.query({ url: url, windowType: 'popup' })
         if (!config.alwaysCreateNewConversationWindow && tabs.length > 0) {
@@ -675,7 +675,7 @@ Browser.runtime.onMessage.addListener(async (message, sender) => {
       }
       case 'REFRESH_MENU':
         console.log('[background] Processing REFRESH_MENU message')
-        refreshMenu()
+        await refreshMenu()
         break
       case 'PIN_TAB': {
         console.log('[background] Processing PIN_TAB message:', message.data)
@@ -1050,7 +1050,8 @@ try {
 
 try {
   refreshMenu()
-  console.log('[background] Menu refreshed successfully.')
+    .then(() => console.log('[background] Menu refreshed successfully.'))
+    .catch((error) => console.error('[background] Error refreshing menu:', error))
 } catch (error) {
   console.error('[background] Error refreshing menu:', error)
 }
diff --git a/src/background/menus.mjs b/src/background/menus.mjs
index d3a61ee1e..d39c11709 100644
--- a/src/background/menus.mjs
+++ b/src/background/menus.mjs
@@ -110,12 +110,11 @@ const onClickMenu = (info, tab) => {
 export function refreshMenu() {
   if (Browser.contextMenus.onClicked.hasListener(onClickMenu))
     Browser.contextMenus.onClicked.removeListener(onClickMenu)
-  Browser.contextMenus.removeAll().then(async () => {
-    if ((await getUserConfig()).hideContextMenu) return
+  return Browser.contextMenus.removeAll().then(async () => {
+    const config = await getUserConfig({ fresh: true })
+    if (config.hideContextMenu) return
 
-    await getPreferredLanguageKey().then((lang) => {
-      changeLanguage(lang)
-    })
+    await changeLanguage(await getPreferredLanguageKey(config))
     Browser.contextMenus.create({
       id: menuId,
       title: 'ChatGPTBox',
diff --git a/src/components/ConversationCard/index.jsx b/src/components/ConversationCard/index.jsx
index 7458a0d89..e9c2be346 100644
--- a/src/components/ConversationCard/index.jsx
+++ b/src/components/ConversationCard/index.jsx
@@ -384,7 +384,7 @@ function ConversationCard(props) {
         }
         foregroundPortsRef.current.add(fakePort)
         try {
-          const bingToken = (await getUserConfig()).bingAccessToken
+          const bingToken = (await getUserConfig({ fresh: true })).bingAccessToken
           if (
             disposedRef.current ||
             disconnected ||
@@ -445,9 +445,13 @@ function ConversationCard(props) {
     }
     const closeChatsEscListener = async (e) => {
       if (e.key !== 'Escape') return
-      const { allowEscToCloseAll } = await getUserConfig()
-      if (disposedRef.current || !allowEscToCloseAll) return
-      closeChatsMessageListener({ type: 'CLOSE_CHATS' })
+      try {
+        const { allowEscToCloseAll } = await getUserConfig({ fresh: true })
+        if (disposedRef.current || !allowEscToCloseAll) return
+        closeChatsMessageListener({ type: 'CLOSE_CHATS' })
+      } catch (error) {
+        console.warn('[ConversationCard] Failed to handle Escape:', error)
+      }
     }
 
     if (props.closeable) {
diff --git a/src/components/WebJumpBackNotification/index.jsx b/src/components/WebJumpBackNotification/index.jsx
index cece185da..527d07246 100644
--- a/src/components/WebJumpBackNotification/index.jsx
+++ b/src/components/WebJumpBackNotification/index.jsx
@@ -56,12 +56,16 @@ const WebJumpBackNotification = (props) => {
           <button
             style={buttonStyle}
             onClick={async () => {
-              Browser.runtime.sendMessage({
-                type: 'ACTIVATE_URL',
-                data: {
-                  tabId: (await getUserConfig()).notificationJumpBackTabId,
-                },
-              })
+              try {
+                await Browser.runtime.sendMessage({
+                  type: 'ACTIVATE_URL',
+                  data: {
+                    tabId: (await getUserConfig({ fresh: true })).notificationJumpBackTabId,
+                  },
+                })
+              } catch (error) {
+                console.warn('[WebJumpBackNotification] Failed to return to source tab:', error)
+              }
             }}
           >
             {t('Go Back')}
diff --git a/src/config/index.mjs b/src/config/index.mjs
index 0a043c38c..6a78581f1 100644
--- a/src/config/index.mjs
+++ b/src/config/index.mjs
@@ -1,4 +1,4 @@
-import { defaults } from 'lodash-es'
+import { cloneDeep, defaults } from 'lodash-es'
 import Browser from 'webextension-polyfill'
 import { isMobile } from '../utils/is-mobile.mjs'
 import {
@@ -19,6 +19,7 @@ import {
   canonicalizeModelKeyArray,
 } from './model-key-migrations.mjs'
 import { getNavigatorLanguage, resolvePreferredLanguageKey } from './language-data.mjs'
+import { hasConfigStorageChange } from './storage-keys.mjs'
 
 export { getNavigatorLanguage }
 
@@ -1065,8 +1066,8 @@ export function isUsingCustomModel(configOrSession) {
   return isInApiModeGroup(customApiModelKeys, configOrSession)
 }
 
-export async function getPreferredLanguageKey() {
-  const config = await getUserConfig()
+export async function getPreferredLanguageKey(config = null) {
+  config ??= await getUserConfig()
   if (config.preferredLanguage === 'auto') return config.userLanguage
   return config.preferredLanguage
 }
@@ -2145,11 +2146,121 @@ function migrateUserConfig(options) {
   return { migrated, dirty, storageKeysToRemove }
 }
 
+let userConfigCache = null
+let userConfigCachePromise = null
+let userConfigCacheGeneration = 0
+let userConfigCacheSequence = 0
+let nextUserConfigReadSequence = 0
+
+function invalidateUserConfigCache() {
+  userConfigCacheGeneration += 1
+  userConfigCache = null
+  userConfigCachePromise = null
+}
+
+// Writers that do not go through setUserConfig (import/export cleanup, for
+// example) are covered by this listener, because the event reaches every
+// extension context. A read that races a write from another context can still
+// return the pre-write config until the event arrives; the UI merges that event
+// into its own state, and setUserConfig closes the window for in-process writes.
+//
+// The area-wide event is used rather than storage.local.onChanged because it is
+// the one every target exposes, and the area is filtered here instead. The
+// listener runs while this module is evaluated, so a missing event would break
+// config loading entirely.
+Browser.storage.onChanged.addListener((changes, areaName) => {
+  if (areaName === 'local' && hasConfigStorageChange(changes)) invalidateUserConfigCache()
+})
+
+// userLanguage and the default it feeds are derived from the browser locale rather
+// than stored, so a locale change has to invalidate the cache like a write does.
+// Without this a context that stays alive across the change, which a service worker
+// or an open panel can be for hours, keeps resolving preferredLanguage against the
+// language the user no longer has.
+if (typeof globalThis.addEventListener === 'function') {
+  globalThis.addEventListener('languagechange', () => invalidateUserConfigCache())
+}
+
 /**
- * get user config from local storage
+ * Get user config from local storage.
+ *
+ * The cache is per context, so it is invalidated by the storage event rather than
+ * by the write that caused it. A read therefore returns the previous config for as
+ * long as another context's completed write has not reached this one yet, which is
+ * invisible for most callers but not for the ones that start a session the moment
+ * the user acts: a selection made right after changing a setting in the popup used
+ * to open with the previous model, because before this cache every read went to
+ * storage. `fresh` is how such a caller opts out.
+ *
+ * @param {{fresh?: boolean}} [options]
+ *   `fresh` reads storage directly instead of the cache, for a read that has to
+ *   observe a write another context has already completed. It still populates the
+ *   cache, so the reads after it are cheap again.
  * @returns {Promise<UserConfig>}
+ *
+ * Every caller gets its own copy, as before, so one caller mutating the result
+ * cannot corrupt the cache or another caller's config. cloneDeep rather than
+ * structuredClone, which only exists from Safari 15.4 while the project declares
+ * no minimum browser version and ships a Safari build. The config is plain JSON
+ * data from storage plus the literal defaults, so a value structuredClone could not
+ * handle cannot reach the cache.
  */
-export async function getUserConfig() {
+export async function getUserConfig({ fresh = false } = {}) {
+  // A read updates the cache only if no newer result has completed since it
+  // started. The generation covers invalidation: a read that began before a change
+  // cannot publish at all. The sequence covers two reads that began after the same
+  // change and finish out of order, which is how an older read would otherwise
+  // replace the config a fresh read had already published.
+  const readAndCache = async (generation, sequence) => {
+    const { config, persisted } = await readAndMigrateUserConfig()
+    if (generation === userConfigCacheGeneration && sequence > userConfigCacheSequence) {
+      userConfigCacheSequence = sequence
+      if (persisted) {
+        userConfigCache = config
+      } else {
+        // A failed migration must also retire older cache and pending reads, so
+        // ordinary callers retry storage instead of falling back to stale settings.
+        invalidateUserConfigCache()
+      }
+    }
+    return config
+  }
+
+  if (fresh) {
+    // Deliberately not shared with any in-flight read, so this cannot join one
+    // that started before the write it has to observe.
+    const sequence = ++nextUserConfigReadSequence
+    return cloneDeep(await readAndCache(userConfigCacheGeneration, sequence))
+  }
+
+  if (userConfigCache) return cloneDeep(userConfigCache)
+  if (!userConfigCachePromise) {
+    const generation = userConfigCacheGeneration
+    const sequence = ++nextUserConfigReadSequence
+    userConfigCachePromise = readAndCache(generation, sequence).finally(() => {
+      if (generation === userConfigCacheGeneration) userConfigCachePromise = null
+    })
+  }
+  return cloneDeep(await userConfigCachePromise)
+}
+
+// Every write a read performs is reported, so the caller knows whether the
+// result it returns is backed by storage.
+const writeAndReport = async (write) => {
+  try {
+    await write()
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function readAndMigrateUserConfig() {
+  // A write that fails leaves storage unchanged, so no storage event would ever
+  // invalidate a cached result built from it. The caller only caches the config
+  // when every write below landed, which keeps a failed migration retryable.
+  let persisted = true
+
   // Also fetch old keys for migration
   const options = await Browser.storage.local.get([
     ...Object.keys(defaultConfig),
@@ -2163,27 +2274,30 @@ export async function getUserConfig() {
   if (options.claudeApiKey !== undefined) {
     if (options.anthropicApiKey === undefined) {
       options.anthropicApiKey = options.claudeApiKey
-      try {
-        await Browser.storage.local.set({ anthropicApiKey: options.claudeApiKey })
-        await Browser.storage.local.remove('claudeApiKey')
-      } catch {
-        // Retry the legacy-key cleanup on the next config read.
-      }
+      // A failure here is retried on the next config read.
+      persisted =
+        (await writeAndReport(async () => {
+          await Browser.storage.local.set({ anthropicApiKey: options.claudeApiKey })
+          await Browser.storage.local.remove('claudeApiKey')
+        })) && persisted
     } else {
-      await Browser.storage.local.remove('claudeApiKey').catch(() => {})
+      persisted =
+        (await writeAndReport(() => Browser.storage.local.remove('claudeApiKey'))) && persisted
     }
   }
   if (options.customClaudeApiUrl !== undefined) {
     if (options.customAnthropicApiUrl === undefined) {
       options.customAnthropicApiUrl = options.customClaudeApiUrl
-      try {
-        await Browser.storage.local.set({ customAnthropicApiUrl: options.customClaudeApiUrl })
-        await Browser.storage.local.remove('customClaudeApiUrl')
-      } catch {
-        // Retry the legacy-key cleanup on the next config read.
-      }
+      // A failure here is retried on the next config read.
+      persisted =
+        (await writeAndReport(async () => {
+          await Browser.storage.local.set({ customAnthropicApiUrl: options.customClaudeApiUrl })
+          await Browser.storage.local.remove('customClaudeApiUrl')
+        })) && persisted
     } else {
-      await Browser.storage.local.remove('customClaudeApiUrl').catch(() => {})
+      persisted =
+        (await writeAndReport(() => Browser.storage.local.remove('customClaudeApiUrl'))) &&
+        persisted
     }
   }
 
@@ -2262,20 +2376,17 @@ export async function getUserConfig() {
     }
     let payloadPersisted = true
     if (Object.keys(payload).length > 0) {
-      payloadPersisted = await Browser.storage.local
-        .set(payload)
-        .then(() => true)
-        .catch(() => false)
+      payloadPersisted = await writeAndReport(() => Browser.storage.local.set(payload))
     }
     if (payloadPersisted && storageKeysToRemove.length > 0) {
-      try {
-        await Browser.storage.local.remove(storageKeysToRemove)
-      } catch {
-        // Invalid live-default sentinels remain non-authoritative and are retried on the next read.
-      }
+      // Invalid live-default sentinels remain non-authoritative and are retried on the next read.
+      payloadPersisted = await writeAndReport(() =>
+        Browser.storage.local.remove(storageKeysToRemove),
+      )
     }
+    persisted = payloadPersisted && persisted
   }
-  return defaults(migrated, defaultConfig)
+  return { config: defaults(migrated, defaultConfig), persisted }
 }
 
 /**
@@ -2284,6 +2395,9 @@ export async function getUserConfig() {
  */
 export async function setUserConfig(value) {
   await Browser.storage.local.set(value)
+  // The storage event also invalidates the cache, but it can arrive after this
+  // promise resolves, so invalidate here to keep the next read consistent.
+  invalidateUserConfigCache()
 }
 
 export async function setAccessToken(accessToken) {
@@ -2293,7 +2407,7 @@ export async function setAccessToken(accessToken) {
 const TOKEN_DURATION = 30 * 24 * 3600 * 1000
 
 export async function clearOldAccessToken() {
-  const duration = Date.now() - (await getUserConfig()).tokenSavedOn
+  const duration = Date.now() - (await getUserConfig({ fresh: true })).tokenSavedOn
   if (duration > TOKEN_DURATION) {
     await setAccessToken('')
   }
diff --git a/src/config/language.mjs b/src/config/language.mjs
index 6b3d85dee..0092b79d3 100644
--- a/src/config/language.mjs
+++ b/src/config/language.mjs
@@ -3,7 +3,7 @@ import { languageList } from './language-data.mjs'
 
 export { languageList }
 
-function formatLanguageForPrompt(languageKey) {
+export function formatLanguageForPrompt(languageKey) {
   const { name, native } = languageList[languageKey]
   return native && native !== name
     ? `${name} (${native}; ${languageKey})`
@@ -20,8 +20,8 @@ export async function getUserLanguageNative() {
   return languageList[config.userLanguage].native
 }
 
-export async function getPreferredLanguage() {
-  return formatLanguageForPrompt(await getPreferredLanguageKey())
+export async function getPreferredLanguage(config = null) {
+  return formatLanguageForPrompt(await getPreferredLanguageKey(config))
 }
 
 export async function getPreferredLanguageNative() {
diff --git a/src/config/storage-keys.mjs b/src/config/storage-keys.mjs
new file mode 100644
index 000000000..c9f8fd4df
--- /dev/null
+++ b/src/config/storage-keys.mjs
@@ -0,0 +1,19 @@
+/**
+ * Storage keys that live next to the user config but are not part of it.
+ *
+ * Conversation history is rewritten after every finished message, so it must
+ * not be treated as a config change by anything that reacts to storage events.
+ */
+export const NON_CONFIG_STORAGE_KEYS = ['sessions']
+
+/**
+ * Whether a storage event carries a change to the user config.
+ *
+ * Only the key matters, not the reported values. Both browsers report the keys
+ * of the call that changed storage, so a conversation history write only ever
+ * mentions `sessions`; Firefox additionally reports keys whose value did not
+ * actually change, which costs a cache miss and can never serve a stale config.
+ */
+export function hasConfigStorageChange(changes) {
+  return Object.keys(changes).some((key) => !NON_CONFIG_STORAGE_KEYS.includes(key))
+}
diff --git a/src/content-script/index.jsx b/src/content-script/index.jsx
index c49164a8b..f25972869 100644
--- a/src/content-script/index.jsx
+++ b/src/content-script/index.jsx
@@ -23,7 +23,7 @@ import {
 } from '../utils'
 import FloatingToolbar from '../components/FloatingToolbar'
 import Browser from 'webextension-polyfill'
-import { getPreferredLanguage } from '../config/language.mjs'
+import { formatLanguageForPrompt, getPreferredLanguage } from '../config/language.mjs'
 import '../_locales/i18n-react'
 import { changeLanguage } from 'i18next'
 import { initSession } from '../services/init-session.mjs'
@@ -43,7 +43,7 @@ async function mountComponent(siteName, siteConfig) {
 
   console.debug('[content] mountComponent called with siteConfig:', siteConfig)
   try {
-    const userConfig = await getUserConfig()
+    const userConfig = await getUserConfig({ fresh: true })
 
     if (!userConfig.alwaysFloatingSidebar) {
       const retry = 10
@@ -240,7 +240,12 @@ const deleteToolbar = () => {
   }
 }
 
-const createSelectionTools = async (toolbarContainerElement, selection, creationVersion) => {
+const createSelectionTools = async (
+  toolbarContainerElement,
+  selection,
+  creationVersion,
+  userConfig = null,
+) => {
   console.debug(
     '[content] createSelectionTools called with selection:',
     selection,
@@ -249,7 +254,9 @@ const createSelectionTools = async (toolbarContainerElement, selection, creation
   )
   try {
     toolbarContainerElement.className = 'chatgptbox-toolbar-container'
-    const userConfig = await getUserConfig()
+    // Fresh, because this starts a session the moment the user selects and the
+    // model it picks has to be the one they just chose in another context.
+    userConfig ??= await getUserConfig({ fresh: true })
     if (
       creationVersion !== toolbarCreationVersion ||
       toolbarContainerElement !== toolbarContainer ||
@@ -314,7 +321,7 @@ async function prepareForSelectionTools() {
             console.debug('[content] Text selected. Length:', selection.length)
             let position
 
-            const config = await getUserConfig()
+            const config = await getUserConfig({ fresh: true })
             if (creationVersion !== toolbarCreationVersion) return
             if (!config.selectionToolsNextToInputBox) {
               position = { x: e.pageX + 20, y: e.pageY + 20 }
@@ -341,7 +348,7 @@ async function prepareForSelectionTools() {
             console.debug('[content] Toolbar position:', position)
             const container = createElementAtPosition(position.x, position.y)
             toolbarContainer = container
-            await createSelectionTools(container, selection, creationVersion)
+            await createSelectionTools(container, selection, creationVersion, config)
           } else {
             console.debug('[content] No text selected on mouseup.')
           }
@@ -492,9 +499,15 @@ async function prepareForRightClickMenu() {
       try {
         const data = message.data
         let prompt = ''
+        // Read the config fresh before anything here consults it. genPrompt() reads
+        // it too, and this is a user gesture that may follow a settings change in
+        // another context whose storage event has not arrived yet, so a cached read
+        // here would build the prompt from the previous configuration while the
+        // session below used the new one.
+        const userConfig = await getUserConfig({ fresh: true })
         if (data.itemId in toolsConfig) {
           console.debug('[content] Generating prompt from toolsConfig for item:', data.itemId)
-          prompt = await toolsConfig[data.itemId].genPrompt(data.selectionText)
+          prompt = await toolsConfig[data.itemId].genPrompt(data.selectionText, userConfig)
         } else if (data.itemId in menuConfig) {
           console.debug('[content] Generating prompt from menuConfig for item:', data.itemId)
           const menuItem = menuConfig[data.itemId]
@@ -504,7 +517,11 @@ async function prepareForRightClickMenu() {
           }
           prompt = await menuItem.genPrompt()
           if (prompt) {
-            const preferredLanguage = await getPreferredLanguage()
+            // Resolved from the config read above rather than through the helpers,
+            // which would read the cache and land back on the previous settings.
+            const preferredLanguage = formatLanguageForPrompt(
+              await getPreferredLanguageKey(userConfig),
+            )
             prompt = await cropText(`Reply in ${preferredLanguage}.\n` + prompt)
           }
         } else {
@@ -521,7 +538,6 @@ async function prepareForRightClickMenu() {
         console.debug('[content] Toolbar position for CREATE_CHAT:', position)
         const container = createElementAtPosition(position.x, position.y)
         container.className = 'chatgptbox-toolbar-container-not-queryable'
-        const userConfig = await getUserConfig()
         render(
           <FloatingToolbar
             session={initSession({
@@ -548,7 +564,7 @@ async function prepareForRightClickMenu() {
 async function prepareForStaticCard() {
   console.log('[content] Initializing static card.')
   try {
-    const userConfig = await getUserConfig()
+    const userConfig = await getUserConfig({ fresh: true })
     let siteRegexPattern
     if (userConfig.useSiteRegexOnly) {
       siteRegexPattern = userConfig.siteRegex
@@ -899,7 +915,7 @@ function ensureChatGptPortListenerRegistered() {
 
   try {
     console.log('[content] Attempting to register port listener for chatgpt.com.')
-    registerPortListener(async (session, port, _config, isLatestSessionRequest) => {
+    registerPortListener(async (session, port, config, isLatestSessionRequest) => {
       console.debug(
         `[content] Port listener callback triggered. Session model: ${session?.modelName}, Port: ${port.name}`,
       )
@@ -919,7 +935,13 @@ function ensureChatGptPortListenerRegistered() {
             port.postMessage({ error: 'Missing ChatGPT access token.' })
             return
           }
-          await generateAnswersWithChatgptWebApi(port, session.question, session, accessToken)
+          await generateAnswersWithChatgptWebApi(
+            port,
+            session.question,
+            session,
+            accessToken,
+            config,
+          )
           console.log('[content] generateAnswersWithChatgptWebApi call completed.')
         } else {
           console.debug(
diff --git a/src/content-script/menu-tools/index.mjs b/src/content-script/menu-tools/index.mjs
index e37ff4c0d..b5aef04fc 100644
--- a/src/content-script/menu-tools/index.mjs
+++ b/src/content-script/menu-tools/index.mjs
@@ -37,7 +37,7 @@ export const config = {
     action: async (fromBackground) => {
       console.debug('action is from background', fromBackground)
       if (fromBackground) {
-        const config = await getUserConfig()
+        const config = await getUserConfig({ fresh: true })
         const url = Browser.runtime.getURL('IndependentPanel.html')
         const tabs = await Browser.tabs.query({ url: url, windowType: 'popup' })
         if (!config.alwaysCreateNewConversationWindow && tabs.length > 0)
diff --git a/src/content-script/selection-tools/index.mjs b/src/content-script/selection-tools/index.mjs
index cfefad817..b9bc5c1f1 100644
--- a/src/content-script/selection-tools/index.mjs
+++ b/src/content-script/selection-tools/index.mjs
@@ -10,6 +10,7 @@ import {
   ChatText,
 } from 'react-bootstrap-icons'
 import { getPreferredLanguage } from '../../config/language.mjs'
+import { getUserConfig } from '../../config/index.mjs'
 
 const createGenPrompt =
   ({
@@ -19,11 +20,13 @@ const createGenPrompt =
     enableBidirectional = false,
     includeLanguagePrefix = false,
   }) =>
-  async (selection) => {
+  async (selection, userConfig = null) => {
     let preferredLanguage = targetLanguage
 
     if (!preferredLanguage) {
-      preferredLanguage = await getPreferredLanguage()
+      preferredLanguage = await getPreferredLanguage(
+        userConfig ?? (await getUserConfig({ fresh: true })),
+      )
     }
 
     let fullMessage = isTranslation
diff --git a/src/hooks/config-storage-listener.mjs b/src/hooks/config-storage-listener.mjs
index 255624ca4..c10970dc8 100644
--- a/src/hooks/config-storage-listener.mjs
+++ b/src/hooks/config-storage-listener.mjs
@@ -1,7 +1,14 @@
+import { NON_CONFIG_STORAGE_KEYS } from '../config/storage-keys.mjs'
+
 export function createConfigStorageListener(setConfig, ignoreSession = true) {
   return (changes) => {
     const changedKeys = Object.keys(changes)
-    if (ignoreSession && changedKeys.length === 1 && changedKeys[0] === 'sessions') return
+    if (
+      ignoreSession &&
+      changedKeys.length === 1 &&
+      NON_CONFIG_STORAGE_KEYS.includes(changedKeys[0])
+    )
+      return
 
     const configUpdate = Object.create(null)
     for (const key of changedKeys) {
diff --git a/src/services/apis/chatgpt-web.mjs b/src/services/apis/chatgpt-web.mjs
index 37f63d518..f7542d38a 100644
--- a/src/services/apis/chatgpt-web.mjs
+++ b/src/services/apis/chatgpt-web.mjs
@@ -11,8 +11,8 @@ import { sha3_512 } from 'js-sha3'
 import randomInt from 'random-int'
 import { getModelValue } from '../../utils/model-name-convert.mjs'
 
-async function request(token, method, path, data) {
-  const apiUrl = (await getUserConfig()).customChatGptWebApiUrl
+async function request(token, method, path, data, config = null) {
+  const apiUrl = (config ?? (await getUserConfig({ fresh: true }))).customChatGptWebApiUrl
   const response = await fetch(`${apiUrl}/backend-api${path}`, {
     method,
     headers: {
@@ -30,12 +30,18 @@ export async function sendMessageFeedback(token, data) {
   await request(token, 'POST', '/conversation/message_feedback', data)
 }
 
-export async function setConversationProperty(token, conversationId, propertyObject) {
-  await request(token, 'PATCH', `/conversation/${conversationId}`, propertyObject)
+export async function setConversationProperty(
+  token,
+  conversationId,
+  propertyObject,
+  config = null,
+) {
+  await request(token, 'PATCH', `/conversation/${conversationId}`, propertyObject, config)
 }
 
-export async function deleteConversation(token, conversationId) {
-  if (conversationId) await setConversationProperty(token, conversationId, { is_visible: false })
+export async function deleteConversation(token, conversationId, config = null) {
+  if (conversationId)
+    await setConversationProperty(token, conversationId, { is_visible: false }, config)
 }
 
 export async function sendModerations(token, question, conversationId, messageId) {
@@ -47,14 +53,17 @@ export async function sendModerations(token, question, conversationId, messageId
   })
 }
 
-export async function getModels(token) {
-  const response = JSON.parse((await request(token, 'GET', '/models')).responseText)
+export async function getModels(token, config = null) {
+  const response = JSON.parse(
+    (await request(token, 'GET', '/models', undefined, config)).responseText,
+  )
   if (response.models) return response.models.map((m) => m.slug)
 }
 
-export async function getRequirements(accessToken) {
+export async function getRequirements(accessToken, config = null) {
   const response = JSON.parse(
-    (await request(accessToken, 'POST', '/sentinel/chat-requirements')).responseText,
+    (await request(accessToken, 'POST', '/sentinel/chat-requirements', undefined, config))
+      .responseText,
   )
   if (response) {
     return response
@@ -149,24 +158,35 @@ function generateProofToken(seed, diff, userAgent) {
   return 'gAAAAABwQ8Lk5FbGpA2NcR9dShT6gYjU7VxZ4D' + fallbackBase
 }
 
-export async function isNeedWebsocket(accessToken) {
-  return (await request(accessToken, 'GET', '/accounts/check/v4-2023-04-27')).responseText.includes(
-    'shared_websocket',
-  )
+export async function isNeedWebsocket(accessToken, config = null) {
+  return (
+    await request(accessToken, 'GET', '/accounts/check/v4-2023-04-27', undefined, config)
+  ).responseText.includes('shared_websocket')
 }
 
-export async function sendWebsocketConversation(accessToken, options) {
-  const apiUrl = (await getUserConfig()).customChatGptWebApiUrl
+export async function sendWebsocketConversation(accessToken, options, config = null) {
+  const apiUrl = (config ?? (await getUserConfig({ fresh: true }))).customChatGptWebApiUrl
   const response = await fetch(`${apiUrl}/backend-api/conversation`, options).then((r) => r.json())
   console.debug(`request: ws /conversation`, response)
   return { conversationId: response.conversation_id, wsRequestId: response.websocket_request_id }
 }
 
-export async function stopWebsocketConversation(accessToken, conversationId, wsRequestId) {
-  await request(accessToken, 'POST', '/stop_conversation', {
-    conversation_id: conversationId,
-    websocket_request_id: wsRequestId,
-  })
+export async function stopWebsocketConversation(
+  accessToken,
+  conversationId,
+  wsRequestId,
+  config = null,
+) {
+  await request(
+    accessToken,
+    'POST',
+    '/stop_conversation',
+    {
+      conversation_id: conversationId,
+      websocket_request_id: wsRequestId,
+    },
+    config,
+  )
 }
 
 /**
@@ -179,11 +199,11 @@ let websocket
 let expires_at
 let wsCallbacks = []
 
-export async function registerWebsocket(accessToken) {
+export async function registerWebsocket(accessToken, config = null) {
   if (websocket && new Date() < expires_at - 300000) return
 
   const response = JSON.parse(
-    (await request(accessToken, 'POST', '/register-websocket')).responseText,
+    (await request(accessToken, 'POST', '/register-websocket', undefined, config)).responseText,
   )
   let resolve
   if (response.wss_url) {
@@ -210,8 +230,15 @@ export async function registerWebsocket(accessToken) {
  * @param {string} question
  * @param {Session} session
  * @param {string} accessToken
+ * @param {UserConfig} [config]
  */
-export async function generateAnswersWithChatgptWebApi(port, question, session, accessToken) {
+export async function generateAnswersWithChatgptWebApi(
+  port,
+  question,
+  session,
+  accessToken,
+  config = null,
+) {
   let wsCallback
   let cleanController = () => {}
   const removeWebsocketCallback = () => {
@@ -221,7 +248,7 @@ export async function generateAnswersWithChatgptWebApi(port, question, session,
   }
   const stopWebsocketRequest = (conversationId, wsRequestId) => {
     if (!wsRequestId) return
-    stopWebsocketConversation(accessToken, conversationId, wsRequestId).catch((error) => {
+    stopWebsocketConversation(accessToken, conversationId, wsRequestId, config).catch((error) => {
       console.warn('[chatgpt-web] Failed to stop WebSocket conversation:', error)
     })
   }
@@ -235,21 +262,21 @@ export async function generateAnswersWithChatgptWebApi(port, question, session,
     () => {
       removeWebsocketCallback()
       cleanController()
-      if (session.autoClean) deleteConversation(accessToken, session.conversationId)
+      if (session.autoClean) deleteConversation(accessToken, session.conversationId, config)
     },
   )
   const { controller } = abortControllerState
   cleanController = abortControllerState.cleanController
 
-  const config = await getUserConfig()
+  config ??= await getUserConfig({ fresh: true })
   let arkoseError
   const [models, requirements, arkoseToken, useWebsocket] = await Promise.all([
-    getModels(accessToken).catch(() => undefined),
-    getRequirements(accessToken).catch(() => undefined),
+    getModels(accessToken, config).catch(() => undefined),
+    getRequirements(accessToken, config).catch(() => undefined),
     getArkoseToken(config).catch((e) => {
       arkoseError = e
     }),
-    isNeedWebsocket(accessToken).catch(() => undefined),
+    isNeedWebsocket(accessToken, config).catch(() => undefined),
   ])
   console.debug('models', models)
   const selectedModel = getModelValue(session)
@@ -342,7 +369,7 @@ export async function generateAnswersWithChatgptWebApi(port, question, session,
       cleanController()
       return
     }
-    await registerWebsocket(accessToken)
+    await registerWebsocket(accessToken, config)
     if (controller.signal.aborted) {
       cleanController()
       return
@@ -378,7 +405,11 @@ export async function generateAnswersWithChatgptWebApi(port, question, session,
     }
     wsCallbacks.push(wsCallback)
     try {
-      const { conversationId, wsRequestId } = await sendWebsocketConversation(accessToken, options)
+      const { conversationId, wsRequestId } = await sendWebsocketConversation(
+        accessToken,
+        options,
+        config,
+      )
       if (controller.signal.aborted) {
         removeWebsocketCallback()
         cleanController()
diff --git a/src/services/local-session.mjs b/src/services/local-session.mjs
index 8ac0f7593..100d59fed 100644
--- a/src/services/local-session.mjs
+++ b/src/services/local-session.mjs
@@ -4,7 +4,11 @@ import { getUserConfig } from '../config/index.mjs'
 import { canonicalizeSessionModelFields } from '../config/model-key-migrations.mjs'
 
 export const initDefaultSession = async () => {
-  const config = await getUserConfig()
+  // Fresh, because this names the model a new conversation starts with, and the
+  // panel holding it can have been open since before the user changed the model in
+  // another context. A cached read here would name the previous model permanently,
+  // where before this cache every call read the completed write.
+  const config = await getUserConfig({ fresh: true })
   return initSession({
     sessionName: new Date().toLocaleString(),
     modelName: config.modelName,
diff --git a/src/services/wrappers.mjs b/src/services/wrappers.mjs
index 09eae487b..e5fd47222 100644
--- a/src/services/wrappers.mjs
+++ b/src/services/wrappers.mjs
@@ -215,22 +215,24 @@ export function registerPortListener(executor) {
         msg.proxyGenerationId,
         msg.requestGenerationId,
       )
-      const config = await getUserConfig()
-      if (!isLatestSessionRequest()) return
-      const language =
-        config.preferredLanguage === 'auto' ? config.userLanguage : config.preferredLanguage
-      const translate = getFixedT(language)
-      if (!session.modelName) session.modelName = config.modelName
-      if (!session.apiMode && session.modelName !== 'customModel') session.apiMode = config.apiMode
-      if (session.apiMode) session.apiMode = normalizeApiMode(session.apiMode)
-      if (!session.aiName)
-        session.aiName = modelNameToDesc(
-          session.apiMode ? apiModeToModelName(session.apiMode) : session.modelName,
-          translate,
-          config.customModelName,
-        )
-      requestPort.postMessage({ session })
+      let translate = t
       try {
+        const config = await getUserConfig({ fresh: true })
+        if (!isLatestSessionRequest()) return
+        const language =
+          config.preferredLanguage === 'auto' ? config.userLanguage : config.preferredLanguage
+        translate = getFixedT(language)
+        if (!session.modelName) session.modelName = config.modelName
+        if (!session.apiMode && session.modelName !== 'customModel')
+          session.apiMode = config.apiMode
+        if (session.apiMode) session.apiMode = normalizeApiMode(session.apiMode)
+        if (!session.aiName)
+          session.aiName = modelNameToDesc(
+            session.apiMode ? apiModeToModelName(session.apiMode) : session.modelName,
+            translate,
+            config.customModelName,
+          )
+        requestPort.postMessage({ session })
         await executor(
           session,
           requestPort,
diff --git a/tests/setup/browser-shim.mjs b/tests/setup/browser-shim.mjs
index 743776441..752a74060 100644
--- a/tests/setup/browser-shim.mjs
+++ b/tests/setup/browser-shim.mjs
@@ -1,5 +1,6 @@
 // Minimal browser-extension API shim for Node test runtime.
 // Scope is intentionally small: only APIs used by current unit tests are mocked.
+import { isDeepStrictEqual } from 'node:util'
 const createEvent = () => {
   const listeners = new Set()
   return {
@@ -59,7 +60,61 @@ const resolveStorageGet = (keys) => {
   return {}
 }
 
+const storageLocalOnChanged = createEvent()
+const storageOnChanged = createEvent()
+
+// Both events of the real API are modelled: the area-specific
+// `storage.local.onChanged` (Chromium 73, Firefox 101, Safari 14) and
+// `storage.onChanged` for every area, which reports the area name as a second
+// argument. Values are compared with structural equality, like Chromium; the
+// `fireUnchangedKeys` option reproduces Firefox, which reports keys of the set
+// call without checking whether the value changed.
+//
+// Events fire synchronously, so an invalidation is observable by the time an
+// awaited `set`/`remove`/`clear` resolves, while the real events arrive later.
+const fireStorageChanged = (
+  before,
+  after,
+  { fireUnchangedKeys = false } = {},
+  writtenKeys = undefined,
+) => {
+  const reportedKeys = new Set([
+    ...Object.keys(before),
+    ...Object.keys(after),
+    ...(writtenKeys ?? []),
+  ])
+
+  const changes = {}
+  for (const key of reportedKeys) {
+    const hadKey = Object.hasOwn(before, key)
+    const hasKey = Object.hasOwn(after, key)
+    const unchanged = hadKey === hasKey && isDeepStrictEqual(before[key], after[key])
+    // Chromium skips unchanged keys, while Firefox reports every key of the
+    // write it performed, so an unchanged key is only reported when it was one
+    // of the written keys.
+    const reportUnchanged = fireUnchangedKeys && writtenKeys?.includes(key)
+    if (unchanged && !reportUnchanged) continue
+    changes[key] = { oldValue: before[key], newValue: after[key] }
+  }
+  if (Object.keys(changes).length === 0) return
+  if (deferStorageEvents) {
+    deferredStorageEvents.push(structuredClone(changes))
+    return
+  }
+  storageLocalOnChanged._trigger(changes)
+  storageOnChanged._trigger(changes, 'local')
+}
+
+// Extension contexts each hold their own module memory but share storage, and the
+// storage-change event is delivered asynchronously, so a write that has already
+// completed in one context is not visible to another until the event reaches it.
+// Holding events back models that window, which is what a test has to reproduce to
+// observe it.
+let deferStorageEvents = false
+const deferredStorageEvents = []
+
 const storageLocal = {
+  onChanged: storageLocalOnChanged,
   get(keys, callback) {
     const result = resolveStorageGet(keys)
     if (typeof callback === 'function') {
@@ -69,7 +124,10 @@ const storageLocal = {
     return Promise.resolve(result)
   },
   set(items, callback) {
+    const before = { ...storageState }
+    const writtenKeys = Object.keys(items ?? {})
     Object.assign(storageState, items ?? {})
+    fireStorageChanged(before, storageState, undefined, writtenKeys)
     if (typeof callback === 'function') {
       queueMicrotask(() => callback())
       return
@@ -77,10 +135,12 @@ const storageLocal = {
     return Promise.resolve()
   },
   remove(keys, callback) {
+    const before = { ...storageState }
     const keyList = Array.isArray(keys) ? keys : [keys]
     for (const key of keyList) {
       delete storageState[key]
     }
+    fireStorageChanged(before, storageState, undefined, keyList)
     if (typeof callback === 'function') {
       queueMicrotask(() => callback())
       return
@@ -88,7 +148,9 @@ const storageLocal = {
     return Promise.resolve()
   },
   clear(callback) {
+    const before = { ...storageState }
     storageState = createStorageState()
+    fireStorageChanged(before, storageState)
     if (typeof callback === 'function') {
       queueMicrotask(() => callback())
       return
@@ -165,6 +227,7 @@ const chromeShim = {
   runtime,
   storage: {
     local: storageLocal,
+    onChanged: storageOnChanged,
   },
   tabs,
   windows,
@@ -185,22 +248,45 @@ if (!globalThis.chrome) {
   globalThis.chrome = chromeShim
 } else {
   globalThis.chrome.runtime ||= runtime
-  globalThis.chrome.storage ||= { local: storageLocal }
+  globalThis.chrome.storage ||= { local: storageLocal, onChanged: storageOnChanged }
   globalThis.chrome.storage.local ||= storageLocal
+  globalThis.chrome.storage.onChanged ||= storageOnChanged
+  globalThis.chrome.storage.local.onChanged ||= storageLocalOnChanged
   globalThis.chrome.tabs ||= tabs
   globalThis.chrome.windows ||= windows
   globalThis.chrome.commands ||= { onCommand: commandsOnCommand }
 }
 
+// The config module listens for locale changes on the global object, which the
+// Node test runtime does not have. This gives the tests the same hook.
+const globalListeners = new Map()
+globalThis.addEventListener = (type, listener) => {
+  if (!globalListeners.has(type)) globalListeners.set(type, new Set())
+  globalListeners.get(type).add(listener)
+}
+globalThis.removeEventListener = (type, listener) => {
+  globalListeners.get(type)?.delete(listener)
+}
 globalThis.__TEST_BROWSER_SHIM__ = {
-  setStorage(values) {
+  // Fire a window-level event, such as the locale change the config module
+  // listens for.
+  dispatchGlobalEvent(type) {
+    for (const listener of [...(globalListeners.get(type) ?? [])]) listener()
+  },
+  setStorage(values, options) {
+    const before = { ...storageState }
     Object.assign(storageState, values)
+    fireStorageChanged(before, storageState, options, Object.keys(values ?? {}))
   },
   replaceStorage(values) {
+    const before = { ...storageState }
     storageState = createStorageState(values)
+    fireStorageChanged(before, storageState)
   },
   clearStorage() {
+    const before = { ...storageState }
     storageState = createStorageState()
+    fireStorageChanged(before, storageState)
   },
   getStorage() {
     return { ...storageState }
@@ -209,4 +295,26 @@ globalThis.__TEST_BROWSER_SHIM__ = {
     runtimeOnMessage._clear()
     commandsOnCommand._clear()
   },
+  resetStorageEvents() {
+    storageLocalOnChanged._clear()
+    storageOnChanged._clear()
+  },
+  // Hold storage-change events back, so a test can read storage in the window
+  // between a write resolving and its event being delivered.
+  deferStorageEvents(defer = true) {
+    deferStorageEvents = defer
+  },
+  // Deliver everything held back, in the order the writes happened.
+  flushStorageEvents() {
+    deferStorageEvents = false
+    const queued = deferredStorageEvents.splice(0)
+    for (const changes of queued) {
+      storageLocalOnChanged._trigger(changes)
+      storageOnChanged._trigger(changes, 'local')
+    }
+    return queued.length
+  },
+  pendingStorageEvents() {
+    return deferredStorageEvents.length
+  },
 }
diff --git a/tests/setup/chatgpt-web-loader-hooks.mjs b/tests/setup/chatgpt-web-loader-hooks.mjs
new file mode 100644
index 000000000..ecc4ee1f4
--- /dev/null
+++ b/tests/setup/chatgpt-web-loader-hooks.mjs
@@ -0,0 +1,10 @@
+// Expose the CommonJS hash through its default export for the Node test runtime.
+// Webpack already handles the named import used by the browser bundle.
+export async function resolve(specifier, context, nextResolve) {
+  if (specifier !== 'js-sha3') return nextResolve(specifier, context)
+
+  const resolved = await nextResolve(specifier, context)
+  const source = `import sha3 from ${JSON.stringify(resolved.url)}
+export const sha3_512 = sha3.sha3_512`
+  return { url: `data:text/javascript,${encodeURIComponent(source)}`, shortCircuit: true }
+}
diff --git a/tests/setup/content-script-selection-toolbar-loader-hooks.mjs b/tests/setup/content-script-selection-toolbar-loader-hooks.mjs
index 654656f71..58c29fa12 100644
--- a/tests/setup/content-script-selection-toolbar-loader-hooks.mjs
+++ b/tests/setup/content-script-selection-toolbar-loader-hooks.mjs
@@ -41,14 +41,17 @@ const sources = {
   'test:config': `
     export const chatgptWebModelKeys = []
     export const getPreferredLanguageKey = async () => 'en'
-    export const getUserConfig = () => globalThis.__SELECTION_TOOLBAR_TEST__.getUserConfig()
+    export const getUserConfig = (options) =>
+      globalThis.__SELECTION_TOOLBAR_TEST__.getUserConfig(options)
     export const isUsingChatgptWebModel = () => false
     export const setAccessToken = async () => {}
     export const setUserConfig = async () => {}
   `,
   'test:utils': `
-    export const createElementAtPosition = () => {
+    export const createElementAtPosition = (x, y) => {
       const element = document.createElement('div')
+      element.style.left = x + 'px'
+      element.style.top = y + 'px'
       document.documentElement.append(element)
       globalThis.__SELECTION_TOOLBAR_TEST__.createdContainers.push(element)
       return element
@@ -72,7 +75,8 @@ const sources = {
       storage: { onChanged: event },
     }
   `,
-  'test:language': `export const getPreferredLanguage = async () => 'English'`,
+  'test:language': `export const getPreferredLanguage = async () => 'English'
+  export const formatLanguageForPrompt = (key) => key`,
   'test:i18n-react': '',
   'test:i18next': 'export const changeLanguage = async () => {}',
   'test:init-session': 'export const initSession = () => ({})',
diff --git a/tests/setup/conversation-card-lifecycle-loader-hooks.mjs b/tests/setup/conversation-card-lifecycle-loader-hooks.mjs
index 3744272b5..308ac55d2 100644
--- a/tests/setup/conversation-card-lifecycle-loader-hooks.mjs
+++ b/tests/setup/conversation-card-lifecycle-loader-hooks.mjs
@@ -74,7 +74,8 @@ const sources = {
     }
   `,
   'test:conversation-config': `
-    export const getUserConfig = () => globalThis.__CONVERSATION_LIFECYCLE_TEST__.getUserConfig()
+    export const getUserConfig = (options) =>
+      globalThis.__CONVERSATION_LIFECYCLE_TEST__.getUserConfig(options)
     export const isUsingBingWebModel = () => globalThis.__CONVERSATION_LIFECYCLE_TEST__.foreground
     export const Models = { customModel: { desc: 'Custom Model' } }
   `,
diff --git a/tests/setup/menu-loader-hooks.mjs b/tests/setup/menu-loader-hooks.mjs
new file mode 100644
index 000000000..e3fa19942
--- /dev/null
+++ b/tests/setup/menu-loader-hooks.mjs
@@ -0,0 +1,10 @@
+// Menu registration does not need the page-content prompt implementations.
+export async function resolve(specifier, context, nextResolve) {
+  if (
+    context.parentURL?.endsWith('/src/background/menus.mjs') &&
+    specifier === '../content-script/menu-tools/index.mjs'
+  ) {
+    return { url: 'data:text/javascript,export const config = {}', shortCircuit: true }
+  }
+  return nextResolve(specifier, context)
+}
diff --git a/tests/setup/web-jump-back-loader-hooks.mjs b/tests/setup/web-jump-back-loader-hooks.mjs
new file mode 100644
index 000000000..fff156a8a
--- /dev/null
+++ b/tests/setup/web-jump-back-loader-hooks.mjs
@@ -0,0 +1,47 @@
+import { readFile } from 'node:fs/promises'
+import { fileURLToPath } from 'node:url'
+
+const stubs = new Map([
+  ['react-i18next', 'test:jump-back-i18n'],
+  ['react-toastify', 'test:jump-back-toast'],
+  ['react-toastify/dist/ReactToastify.css', 'test:jump-back-styles'],
+  ['../../hooks/use-theme.mjs', 'test:jump-back-theme'],
+])
+
+const sources = {
+  'test:jump-back-i18n': 'export const useTranslation = () => ({ t: (value) => value })',
+  'test:jump-back-toast': `
+    export const toast = (content) => {
+      globalThis.__JUMP_BACK_TEST__.content = content
+    }
+    export const ToastContainer = () => null
+  `,
+  'test:jump-back-styles': '',
+  'test:jump-back-theme': `
+    export const useTheme = () => ['light', { themeMode: 'light', preferredLanguage: 'en' }]
+  `,
+}
+
+export async function resolve(specifier, context, nextResolve) {
+  if (context.parentURL?.endsWith('/src/components/WebJumpBackNotification/index.jsx')) {
+    const stubUrl = stubs.get(specifier)
+    if (stubUrl) return { url: stubUrl, shortCircuit: true }
+  }
+  return nextResolve(specifier, context)
+}
+
+export async function load(url, context, nextLoad) {
+  if (url.startsWith('test:jump-back-')) {
+    return { shortCircuit: true, format: 'module', source: sources[url] }
+  }
+  if (url.endsWith('/src/components/WebJumpBackNotification/index.jsx')) {
+    const { transform } = await import('esbuild')
+    const { code } = await transform(await readFile(fileURLToPath(url), 'utf8'), {
+      loader: 'jsx',
+      jsx: 'automatic',
+      jsxImportSource: 'preact',
+    })
+    return { shortCircuit: true, format: 'module', source: code }
+  }
+  return nextLoad(url, context)
+}
diff --git a/tests/unit/background/menus.test.mjs b/tests/unit/background/menus.test.mjs
new file mode 100644
index 000000000..c98adc137
--- /dev/null
+++ b/tests/unit/background/menus.test.mjs
@@ -0,0 +1,43 @@
+import assert from 'node:assert/strict'
+import { register } from 'node:module'
+import { test } from 'node:test'
+import i18n from 'i18next'
+import { getUserConfig } from '../../../src/config/index.mjs'
+
+const createdMenus = []
+const listeners = new Set()
+globalThis.chrome.contextMenus = {
+  onClicked: {
+    addListener: (listener) => listeners.add(listener),
+    removeListener: (listener) => listeners.delete(listener),
+    hasListener: (listener) => listeners.has(listener),
+  },
+  removeAll(callback) {
+    createdMenus.length = 0
+    queueMicrotask(callback)
+  },
+  create(options) {
+    createdMenus.push(options)
+    return options.id
+  },
+}
+
+register(new URL('../../setup/menu-loader-hooks.mjs', import.meta.url))
+const { refreshMenu } = await import('../../../src/background/menus.mjs')
+
+test('menu refresh observes the hide preference before its storage event arrives', async (t) => {
+  await i18n.init({ lng: 'en', resources: { en: { translation: {} } } })
+  const shim = globalThis.__TEST_BROWSER_SHIM__
+  shim.replaceStorage({ hideContextMenu: false })
+  for (let attempt = 0; attempt < 3; attempt++) await getUserConfig()
+  shim.deferStorageEvents()
+  t.after(() => shim.flushStorageEvents())
+
+  shim.setStorage({ hideContextMenu: true })
+  await refreshMenu()
+  assert.equal(createdMenus.length, 0, 'the committed hide setting must take effect')
+
+  shim.setStorage({ hideContextMenu: false })
+  await refreshMenu()
+  assert.ok(createdMenus.some((menu) => menu.id === 'ChatGPTBox-Menu'))
+})
diff --git a/tests/unit/components/conversation-card-lifecycle.test.mjs b/tests/unit/components/conversation-card-lifecycle.test.mjs
index 0319d941c..2cf688eef 100644
--- a/tests/unit/components/conversation-card-lifecycle.test.mjs
+++ b/tests/unit/components/conversation-card-lifecycle.test.mjs
@@ -6,6 +6,18 @@ import { pathToFileURL } from 'node:url'
 import { JSDOM } from 'jsdom'
 import { h, render } from 'preact'
 import { act } from 'preact/test-utils'
+import { getUserConfig } from '../../../src/config/index.mjs'
+
+const { setUserConfig: setWriterConfig } = await import(
+  '../../../src/config/index.mjs?conversation-card-writer'
+)
+const shim = globalThis.__TEST_BROWSER_SHIM__
+
+const warmConfigCache = async (config) => {
+  shim.flushStorageEvents()
+  shim.replaceStorage(config)
+  for (let attempt = 0; attempt < 3; attempt++) await getUserConfig()
+}
 
 register(
   './tests/setup/conversation-card-lifecycle-loader-hooks.mjs',
@@ -325,6 +337,96 @@ test('remote runtime Port disconnect reconnects and unmount cleans the replaceme
   assert.equal(state.ports.length, 2)
 })
 
+test('foreground sends observe a token update before its storage event', async (t) => {
+  await warmConfigCache({ bingAccessToken: 'old-token' })
+  const state = globalThis.__CONVERSATION_LIFECYCLE_TEST__
+  state.foreground = true
+  state.getUserConfig = getUserConfig
+  let suppliedToken
+  state.generateAnswers = async (_port, _question, _session, token) => {
+    suppliedToken = token
+  }
+  const container = document.createElement('div')
+  document.body.append(container)
+  mountCard(container)
+  await waitFor(
+    () => typeof state.inputBoxProps?.onSubmit === 'function',
+    'InputBox did not render',
+  )
+
+  shim.deferStorageEvents()
+  t.after(() => shim.flushStorageEvents())
+  await setWriterConfig({ bingAccessToken: 'new-token' })
+  assert.ok(shim.pendingStorageEvents() > 0)
+  await state.inputBoxProps.onSubmit('question')
+
+  assert.equal(suppliedToken, 'new-token')
+})
+
+test('Escape observes preference changes before their storage events', async (t) => {
+  await warmConfigCache({ allowEscToCloseAll: true })
+  const state = globalThis.__CONVERSATION_LIFECYCLE_TEST__
+  state.getUserConfig = getUserConfig
+  const onClose = t.mock.fn()
+  const container = document.createElement('div')
+  document.body.append(container)
+  mountCard(container, { closeable: true, onClose })
+
+  shim.deferStorageEvents()
+  t.after(() => shim.flushStorageEvents())
+  await setWriterConfig({ allowEscToCloseAll: false })
+  assert.ok(shim.pendingStorageEvents() > 0)
+  await act(async () => {
+    window.dispatchEvent(new window.KeyboardEvent('keydown', { key: 'Escape' }))
+    await nextTask()
+  })
+
+  assert.equal(onClose.mock.callCount(), 0)
+
+  await setWriterConfig({ allowEscToCloseAll: true })
+  await act(async () => {
+    window.dispatchEvent(new window.KeyboardEvent('keydown', { key: 'Escape' }))
+    await nextTask()
+  })
+  assert.equal(onClose.mock.callCount(), 1)
+})
+
+test('Escape read failures keep the conversation open and allow retry', async (t) => {
+  await warmConfigCache({ allowEscToCloseAll: true })
+  const state = globalThis.__CONVERSATION_LIFECYCLE_TEST__
+  state.getUserConfig = getUserConfig
+  const onClose = t.mock.fn()
+  const warning = t.mock.method(console, 'warn', () => {})
+  const container = document.createElement('div')
+  document.body.append(container)
+  mountCard(container, { closeable: true, onClose })
+  const get = t.mock.method(globalThis.chrome.storage.local, 'get', (_keys, callback) => {
+    globalThis.chrome.runtime.lastError = { message: 'storage unavailable' }
+    try {
+      callback(undefined)
+    } finally {
+      delete globalThis.chrome.runtime.lastError
+    }
+  })
+
+  await act(async () => {
+    window.dispatchEvent(new window.KeyboardEvent('keydown', { key: 'Escape' }))
+    await nextTask()
+  })
+
+  assert.equal(warning.mock.callCount(), 1)
+  assert.match(warning.mock.calls[0].arguments[1].message, /storage unavailable/)
+  assert.equal(onClose.mock.callCount(), 0)
+  assert.equal(state.ports[0].disconnected, false)
+
+  get.mock.restore()
+  await act(async () => {
+    window.dispatchEvent(new window.KeyboardEvent('keydown', { key: 'Escape' }))
+    await nextTask()
+  })
+  assert.equal(onClose.mock.callCount(), 1)
+})
+
 test('close button disposes foreground transport before onClose', async () => {
   const state = globalThis.__CONVERSATION_LIFECYCLE_TEST__
   const container = document.createElement('div')
diff --git a/tests/unit/components/web-jump-back-notification.test.mjs b/tests/unit/components/web-jump-back-notification.test.mjs
new file mode 100644
index 000000000..45b57a340
--- /dev/null
+++ b/tests/unit/components/web-jump-back-notification.test.mjs
@@ -0,0 +1,147 @@
+import assert from 'node:assert/strict'
+import { register } from 'node:module'
+import { after, afterEach, before, test } from 'node:test'
+import { JSDOM } from 'jsdom'
+import { h, render } from 'preact'
+import { act } from 'preact/test-utils'
+import { getUserConfig } from '../../../src/config/index.mjs'
+
+register(new URL('../../setup/web-jump-back-loader-hooks.mjs', import.meta.url))
+
+const { setUserConfig: setWriterConfig } = await import(
+  '../../../src/config/index.mjs?jump-back-writer'
+)
+const shim = globalThis.__TEST_BROWSER_SHIM__
+const originalDescriptors = new Map()
+const globalNames = ['window', 'document', 'Node', 'HTMLElement']
+const nextTask = () => new Promise((resolve) => setTimeout(resolve, 0))
+const waitFor = async (predicate, message) => {
+  for (let attempt = 0; attempt < 50; attempt++) {
+    if (predicate()) return
+    await nextTask()
+  }
+  assert.fail(message)
+}
+
+let dom
+let WebJumpBackNotification
+let container
+let toastContainer
+
+const mountNotification = async () => {
+  container = document.createElement('div')
+  toastContainer = document.createElement('div')
+  document.body.append(container, toastContainer)
+  act(() => render(h(WebJumpBackNotification, { chatgptMode: false }), container))
+  await waitFor(() => globalThis.__JUMP_BACK_TEST__.content, 'notification did not render')
+  act(() => render(globalThis.__JUMP_BACK_TEST__.content, toastContainer))
+  const button = toastContainer.querySelector('button')
+  assert.equal(button?.textContent, 'Go Back')
+  return button
+}
+
+before(async () => {
+  dom = new JSDOM('<!doctype html><html><body></body></html>', { url: 'https://example.com/' })
+  for (const name of globalNames) {
+    originalDescriptors.set(name, Object.getOwnPropertyDescriptor(globalThis, name))
+    Object.defineProperty(globalThis, name, { configurable: true, value: dom.window[name] })
+  }
+  globalThis.__JUMP_BACK_TEST__ = {}
+  ;({ default: WebJumpBackNotification } = await import(
+    '../../../src/components/WebJumpBackNotification/index.jsx'
+  ))
+})
+
+afterEach(() => {
+  act(() => {
+    if (container) render(null, container)
+    if (toastContainer) render(null, toastContainer)
+  })
+  document.body.replaceChildren()
+  delete globalThis.__JUMP_BACK_TEST__.content
+  container = null
+  toastContainer = null
+})
+
+after(() => {
+  dom.window.close()
+  delete globalThis.__JUMP_BACK_TEST__
+  for (const [name, descriptor] of originalDescriptors) {
+    if (descriptor) Object.defineProperty(globalThis, name, descriptor)
+    else delete globalThis[name]
+  }
+})
+
+test('Go Back observes updated target tabs before their storage events', async (t) => {
+  shim.replaceStorage({ notificationJumpBackTabId: 101 })
+  for (let attempt = 0; attempt < 3; attempt++) await getUserConfig()
+  const button = await mountNotification()
+  const messages = []
+  t.mock.method(globalThis.chrome.runtime, 'sendMessage', (message, callback) => {
+    messages.push(message)
+    callback?.()
+  })
+
+  shim.deferStorageEvents()
+  t.after(() => shim.flushStorageEvents())
+  for (const tabId of [202, 303]) {
+    await setWriterConfig({ notificationJumpBackTabId: tabId })
+    assert.ok(shim.pendingStorageEvents() > 0)
+    const count = messages.length
+    act(() => button.click())
+    await waitFor(() => messages.length > count, 'Go Back did not send its message')
+    assert.deepEqual(messages.at(-1), { type: 'ACTIVATE_URL', data: { tabId } })
+  }
+})
+
+test('Go Back handles read and activation failures and allows retry', async (t) => {
+  shim.replaceStorage({ notificationJumpBackTabId: 202 })
+  for (let attempt = 0; attempt < 3; attempt++) await getUserConfig()
+  const button = await mountNotification()
+  const warning = t.mock.method(console, 'warn', () => {})
+  const messages = []
+  const send = t.mock.method(globalThis.chrome.runtime, 'sendMessage', (message, callback) => {
+    messages.push(message)
+    callback?.()
+  })
+  const get = t.mock.method(globalThis.chrome.storage.local, 'get', (_keys, callback) => {
+    globalThis.chrome.runtime.lastError = { message: 'storage unavailable' }
+    try {
+      callback(undefined)
+    } finally {
+      delete globalThis.chrome.runtime.lastError
+    }
+  })
+
+  act(() => button.click())
+  await waitFor(() => warning.mock.callCount() === 1, 'read failure was not handled')
+  assert.match(warning.mock.calls[0].arguments[1].message, /storage unavailable/)
+  assert.equal(messages.length, 0)
+
+  get.mock.restore()
+  send.mock.restore()
+  const failedSend = t.mock.method(
+    globalThis.chrome.runtime,
+    'sendMessage',
+    (_message, callback) => {
+      globalThis.chrome.runtime.lastError = { message: 'target tab unavailable' }
+      try {
+        callback(undefined)
+      } finally {
+        delete globalThis.chrome.runtime.lastError
+      }
+    },
+  )
+  act(() => button.click())
+  await waitFor(() => warning.mock.callCount() === 2, 'activation failure was not handled')
+  assert.match(warning.mock.calls[1].arguments[1].message, /target tab unavailable/)
+
+  failedSend.mock.restore()
+  t.mock.method(globalThis.chrome.runtime, 'sendMessage', (message, callback) => {
+    messages.push(message)
+    callback?.()
+  })
+  act(() => button.click())
+  await waitFor(() => messages.length === 1, 'Go Back did not recover')
+  assert.deepEqual(messages[0], { type: 'ACTIVATE_URL', data: { tabId: 202 } })
+})
diff --git a/tests/unit/config/language-config.test.mjs b/tests/unit/config/language-config.test.mjs
index 46ff0eca0..2e54010ac 100644
--- a/tests/unit/config/language-config.test.mjs
+++ b/tests/unit/config/language-config.test.mjs
@@ -98,6 +98,14 @@ test('auto resolves through the refreshed browser language', async () => {
   assert.equal(await getPreferredLanguageKey(), 'zh-Hant')
 })
 
+test('resolves preferred language from a supplied config snapshot', async () => {
+  assert.equal(
+    await getPreferredLanguageKey({ preferredLanguage: 'auto', userLanguage: 'zh-Hant' }),
+    'zh-Hant',
+  )
+  assert.equal(await getPreferredLanguageKey({ preferredLanguage: 'fr', userLanguage: 'en' }), 'fr')
+})
+
 test('formats preferred language with native name and canonical tag for prompts', async () => {
   globalThis.__TEST_BROWSER_SHIM__.replaceStorage({ preferredLanguage: 'zh-Hant' })
 
diff --git a/tests/unit/config/user-config-cache.test.mjs b/tests/unit/config/user-config-cache.test.mjs
new file mode 100644
index 000000000..708cd1426
--- /dev/null
+++ b/tests/unit/config/user-config-cache.test.mjs
@@ -0,0 +1,329 @@
+import assert from 'node:assert/strict'
+import { beforeEach, test } from 'node:test'
+
+// Count storage reads. The patch has to be installed before anything walks the
+// storage API, so the config module is imported dynamically below.
+let storageReadCount = 0
+const originalStorageGet = globalThis.chrome.storage.local.get
+globalThis.chrome.storage.local.get = function countedStorageGet(...args) {
+  storageReadCount += 1
+  return originalStorageGet.apply(this, args)
+}
+
+const { defaultConfig, getUserConfig, setUserConfig } = await import(
+  '../../../src/config/index.mjs'
+)
+const shim = globalThis.__TEST_BROWSER_SHIM__
+
+beforeEach(() => {
+  // Write a real config key so the storage event invalidates the cache whatever
+  // the previous test left behind, then start from empty storage.
+  shim.setStorage({ modelName: 'reset-between-tests' })
+  shim.clearStorage()
+  storageReadCount = 0
+})
+
+// Reading fresh storage performs one-time migration writes, and those writes
+// invalidate the read that made them, so the first read never reaches the cache.
+// Tests that count storage reads read until the count stops growing, so they
+// measure the cache and not however many reads the migration happens to need.
+const warmUpCache = async () => {
+  let previousCount = -1
+  for (let attempt = 0; attempt < 10 && previousCount !== storageReadCount; attempt++) {
+    previousCount = storageReadCount
+    await getUserConfig()
+  }
+  storageReadCount = 0
+}
+
+test('repeated reads reuse one storage read', async () => {
+  await warmUpCache()
+  shim.setStorage({ modelName: 'one-read-only' })
+
+  const first = await getUserConfig()
+  const second = await getUserConfig()
+  const third = await getUserConfig()
+
+  // The first read after a change misses, the two after it hit the cache.
+  assert.equal(storageReadCount, 1)
+  assert.equal(first.modelName, 'one-read-only')
+  assert.deepEqual(second, first)
+  assert.deepEqual(third, first)
+})
+
+test('concurrent reads share a single storage read', async () => {
+  await warmUpCache()
+  shim.setStorage({ modelName: 'concurrent' })
+
+  const configs = await Promise.all([getUserConfig(), getUserConfig(), getUserConfig()])
+
+  // The cache is cold here, so the three calls have to share one read.
+  assert.equal(storageReadCount, 1)
+  assert.equal(configs[0].modelName, 'concurrent')
+  assert.deepEqual(configs[1], configs[0])
+  assert.deepEqual(configs[2], configs[0])
+})
+
+test('each caller gets an independent object', async () => {
+  shim.setStorage({
+    providerSecrets: { openai: 'sk-test-original' },
+    customApiModes: [
+      {
+        id: 'custom-mode',
+        name: 'Custom',
+        apiMode: 'customModel',
+        active: false,
+        customUrl: 'https://example.com/v1/chat/completions',
+        customProvider: 'openai',
+      },
+    ],
+  })
+
+  const first = await getUserConfig()
+  const second = await getUserConfig()
+
+  first.modelName = 'mutated'
+  first.providerSecrets.openai = 'sk-test-mutated'
+  first.customApiModes[0].active = true
+
+  assert.notEqual(second.modelName, 'mutated')
+  assert.equal(second.providerSecrets.openai, 'sk-test-original')
+  assert.equal(second.customApiModes[0].active, false)
+
+  const third = await getUserConfig()
+  assert.equal(third.providerSecrets.openai, 'sk-test-original')
+  assert.equal(third.customApiModes[0].active, false)
+})
+
+test('setUserConfig invalidates the cache', async () => {
+  await warmUpCache()
+  await setUserConfig({ modelName: 'gpt-4o' })
+  const config = await getUserConfig()
+
+  assert.equal(config.modelName, 'gpt-4o')
+  assert.equal(storageReadCount, 1)
+})
+
+test('a direct storage write invalidates the cache', async () => {
+  await warmUpCache()
+  shim.setStorage({ modelName: 'gpt-4o-mini' })
+
+  assert.equal((await getUserConfig()).modelName, 'gpt-4o-mini')
+  assert.equal(storageReadCount, 1, 'the write must cost a storage read')
+})
+
+test('a sessions write does not invalidate the cache', async () => {
+  await warmUpCache()
+  shim.setStorage({ sessions: [{ conversations: [] }] })
+
+  await getUserConfig()
+  assert.equal(storageReadCount, 0)
+})
+
+test('a config write does invalidate the cache', async () => {
+  // Control for the sessions test above: the counter has to move here.
+  await warmUpCache()
+  shim.setStorage({ modelName: 'gpt-4o' })
+
+  await getUserConfig()
+  assert.equal(storageReadCount, 1)
+})
+
+test('a reported config key invalidates the cache even when its value is unchanged', async () => {
+  // Stored first, so writing the same value back is a real no-op that only
+  // Firefox would report.
+  shim.setStorage({ activeSelectionTools: ['translate'] })
+  await warmUpCache()
+
+  // Firefox reports the keys of the set call without checking whether the value
+  // actually changed, so a config key written next to a conversation history
+  // update arrives as a no-op change. Dropping the cache there is a missed
+  // optimisation, never a stale read.
+  shim.setStorage(
+    { sessions: [{ conversations: [] }], activeSelectionTools: ['translate'] },
+    { fireUnchangedKeys: true },
+  )
+
+  await getUserConfig()
+  assert.equal(storageReadCount, 1)
+})
+
+test('removing a config key invalidates the cache', async () => {
+  await setUserConfig({ modelName: 'gpt-4o' })
+  await getUserConfig()
+  shim.clearStorage()
+
+  assert.notEqual((await getUserConfig()).modelName, 'gpt-4o')
+})
+
+test('a migration is applied once and then cached', async () => {
+  shim.setStorage({ claudeApiKey: 'legacy-key' })
+
+  const first = await getUserConfig()
+  assert.equal(first.anthropicApiKey, 'legacy-key')
+  assert.equal(Object.hasOwn(shim.getStorage(), 'claudeApiKey'), false)
+
+  // The migration write invalidates the read that triggered it, so the next one
+  // re-reads the migrated storage and every read after that is served from the
+  // cache.
+  await getUserConfig()
+  await getUserConfig()
+  assert.equal(storageReadCount, 2)
+  assert.equal((await getUserConfig()).anthropicApiKey, 'legacy-key')
+  assert.equal(storageReadCount, 2)
+})
+
+test('a change during a read is not cached', async (t) => {
+  const patchedGet = globalThis.chrome.storage.local.get
+  t.after(() => {
+    globalThis.chrome.storage.local.get = patchedGet
+  })
+
+  shim.setStorage({ modelName: 'before-read' })
+  globalThis.chrome.storage.local.get = function racingGet(...args) {
+    const result = patchedGet.apply(this, args)
+    // A write that lands while the read is in flight must not leave the
+    // pre-write value in the cache.
+    shim.setStorage({ modelName: 'during-read' })
+    return result
+  }
+
+  assert.equal((await getUserConfig()).modelName, 'before-read')
+  assert.equal(storageReadCount, 1)
+  assert.equal((await getUserConfig()).modelName, 'during-read')
+  assert.equal(storageReadCount, 2, 'the value that landed mid-read must not be cached')
+})
+
+test('a failed read is not cached', async (t) => {
+  const patchedGet = globalThis.chrome.storage.local.get
+  t.after(() => {
+    globalThis.chrome.storage.local.get = patchedGet
+  })
+
+  // The polyfill calls storage through a callback and reports failures with
+  // runtime.lastError, so the failure has to be shaped that way.
+  globalThis.chrome.storage.local.get = function failingGet(_keys, callback) {
+    globalThis.chrome.runtime.lastError = { message: 'storage unavailable' }
+    try {
+      callback(undefined)
+    } finally {
+      delete globalThis.chrome.runtime.lastError
+    }
+  }
+  await assert.rejects(async () => {
+    await getUserConfig()
+  }, /storage unavailable/)
+
+  globalThis.chrome.storage.local.get = patchedGet
+  const recovered = await getUserConfig()
+  assert.equal(recovered.modelName, defaultConfig.modelName)
+  // The failing reads replaced the counting wrapper, so only the recovery is
+  // counted here.
+  assert.equal(storageReadCount, 1, 'the recovery must read storage again')
+})
+
+test('a migration that could not be persisted is not cached', async (t) => {
+  const patchedSet = globalThis.chrome.storage.local.set
+  t.after(() => {
+    globalThis.chrome.storage.local.set = patchedSet
+  })
+
+  shim.setStorage({ claudeApiKey: 'legacy-key' })
+
+  // A failed write produces no storage event, so nothing else would ever
+  // invalidate a cached result built from it.
+  globalThis.chrome.storage.local.set = function failingSet(_items, callback) {
+    globalThis.chrome.runtime.lastError = { message: 'quota exceeded' }
+    try {
+      callback?.()
+    } finally {
+      delete globalThis.chrome.runtime.lastError
+    }
+  }
+
+  const config = await getUserConfig()
+  assert.equal(config.anthropicApiKey, 'legacy-key')
+  assert.equal(Object.hasOwn(shim.getStorage(), 'claudeApiKey'), true)
+
+  // The next read retries the migration instead of serving a cached copy.
+  globalThis.chrome.storage.local.set = patchedSet
+  const retried = await getUserConfig()
+  assert.equal(retried.anthropicApiKey, 'legacy-key')
+  assert.equal(Object.hasOwn(shim.getStorage(), 'claudeApiKey'), false)
+})
+
+test('a legacy key removal that fails is retried on the next read', async (t) => {
+  // Settle baseline migrations so their events cannot mask a cached failed removal.
+  shim.setStorage({ anthropicApiKey: 'new-key' })
+  await warmUpCache()
+  const writes = t.mock.method(globalThis.chrome.storage.local, 'set')
+  const patchedRemove = globalThis.chrome.storage.local.remove
+  t.after(() => {
+    globalThis.chrome.storage.local.remove = patchedRemove
+  })
+
+  // Both keys present: the read has to drop the legacy one, and a failed
+  // removal produces no storage event, so the result must not be cached.
+  shim.setStorage({ claudeApiKey: 'legacy-key' })
+
+  const removals = []
+  globalThis.chrome.storage.local.remove = function failingRemove(keys, callback) {
+    removals.push(keys)
+    globalThis.chrome.runtime.lastError = { message: 'removal failed' }
+    try {
+      callback?.()
+    } finally {
+      delete globalThis.chrome.runtime.lastError
+    }
+  }
+
+  assert.equal((await getUserConfig()).anthropicApiKey, 'new-key')
+  assert.deepEqual(removals, ['claudeApiKey'])
+  assert.equal(writes.mock.callCount(), 0, 'no other migration may invalidate the failed read')
+  assert.equal(Object.hasOwn(shim.getStorage(), 'claudeApiKey'), true)
+
+  // The next read tries the removal again instead of serving a cached copy.
+  globalThis.chrome.storage.local.remove = patchedRemove
+  await getUserConfig()
+  assert.equal(Object.hasOwn(shim.getStorage(), 'claudeApiKey'), false)
+})
+
+test('a change in another storage area does not invalidate the cache', async () => {
+  await warmUpCache()
+
+  globalThis.chrome.storage.onChanged._trigger(
+    { modelName: { oldValue: 'gpt-4o', newValue: 'gpt-4o-mini' } },
+    'sync',
+  )
+
+  await getUserConfig()
+  assert.equal(storageReadCount, 0, 'only the local area holds the user config')
+})
+
+test('concurrent callers all see a rejected read and the next one recovers', async (t) => {
+  const patchedGet = globalThis.chrome.storage.local.get
+  t.after(() => {
+    globalThis.chrome.storage.local.get = patchedGet
+  })
+
+  await warmUpCache()
+  shim.setStorage({ modelName: 'read-that-fails' })
+  globalThis.chrome.storage.local.get = function failingGet(_keys, callback) {
+    globalThis.chrome.runtime.lastError = { message: 'storage unavailable' }
+    try {
+      callback(undefined)
+    } finally {
+      delete globalThis.chrome.runtime.lastError
+    }
+  }
+
+  const reads = [getUserConfig(), getUserConfig(), getUserConfig()]
+  for (const read of reads) {
+    await assert.rejects(() => read, /storage unavailable/)
+  }
+
+  // The failed read must not be cached, and the rejected promise must not be
+  // reused by later callers.
+  globalThis.chrome.storage.local.get = patchedGet
+  assert.equal((await getUserConfig()).modelName, 'read-that-fails')
+})
diff --git a/tests/unit/config/user-config-cross-context.test.mjs b/tests/unit/config/user-config-cross-context.test.mjs
new file mode 100644
index 000000000..73764b663
--- /dev/null
+++ b/tests/unit/config/user-config-cross-context.test.mjs
@@ -0,0 +1,233 @@
+import assert from 'node:assert/strict'
+import { afterEach, beforeEach, test } from 'node:test'
+import { setImmediate } from 'node:timers/promises'
+import {
+  clearOldAccessToken,
+  getUserConfig as getReaderConfig,
+} from '../../../src/config/index.mjs'
+
+const shim = globalThis.__TEST_BROWSER_SHIM__
+
+// Extension contexts each evaluate their own copy of the config module but share
+// one storage area, and the storage-change event that tells one context about a
+// write in another arrives asynchronously. A second copy of the module stands in
+// for the second context, so a test can hold the event back and read in the window
+// where the two disagree.
+let setWriterConfig
+let getWriterConfig
+let writerGeneration = 0
+const loadWriterContext = async () => {
+  writerGeneration += 1
+  const writer = await import(`../../../src/config/index.mjs?cross-context=${writerGeneration}`)
+  setWriterConfig = writer.setUserConfig
+  getWriterConfig = writer.getUserConfig
+}
+
+beforeEach(async () => {
+  // Reset stored migrations as well as the model so each test starts independently.
+  shim.flushStorageEvents()
+  shim.replaceStorage({ modelName: 'before-each' })
+  await loadWriterContext()
+  // Reading fresh storage performs migration writes, and those writes invalidate
+  // the read that made them, so the first read never reaches the cache. Read until
+  // the storage events stop arriving rather than assuming one read is enough.
+  for (let attempt = 0; attempt < 10; attempt++) {
+    shim.deferStorageEvents()
+    await getReaderConfig()
+    if (shim.pendingStorageEvents() === 0) break
+    shim.flushStorageEvents()
+  }
+  shim.deferStorageEvents(false)
+})
+
+afterEach(() => {
+  shim.flushStorageEvents()
+})
+
+test('the cached read serves the old config until the event arrives', async () => {
+  await getReaderConfig()
+
+  // Another context writes, and its event is held back.
+  shim.deferStorageEvents()
+  await setWriterConfig({ modelName: 'written-in-the-other-context' })
+  assert.equal(shim.getStorage().modelName, 'written-in-the-other-context', 'the write completed')
+
+  const stale = await getReaderConfig()
+  assert.equal(
+    stale.modelName,
+    'before-each',
+    'this is the window the cache cannot see, and the reason fresh exists',
+  )
+
+  shim.flushStorageEvents()
+  assert.equal((await getReaderConfig()).modelName, 'written-in-the-other-context')
+})
+
+test('a fresh read observes a completed cross-context write before its event', async (t) => {
+  await getReaderConfig()
+
+  shim.deferStorageEvents()
+  await setWriterConfig({ modelName: 'written-in-the-other-context' })
+
+  let storageReads = 0
+  const originalGet = globalThis.chrome.storage.local.get
+  t.mock.method(globalThis.chrome.storage.local, 'get', function (...args) {
+    storageReads += 1
+    return originalGet.apply(this, args)
+  })
+
+  // This is what the selection toolbar and the context menu do: they start a
+  // session on the user's gesture, so they cannot wait for the event.
+  const fresh = await getReaderConfig({ fresh: true })
+  assert.equal(fresh.modelName, 'written-in-the-other-context')
+  assert.equal(storageReads, 1)
+
+  // Check the hit before delivering the event, which invalidates the fresh cache.
+  assert.equal((await getReaderConfig()).modelName, 'written-in-the-other-context')
+  assert.equal(storageReads, 1, 'the fresh read must populate the cache')
+
+  shim.flushStorageEvents()
+  assert.equal((await getReaderConfig()).modelName, 'written-in-the-other-context')
+  assert.equal(storageReads, 2, 'the delivered event must invalidate the cache')
+})
+
+test('an older read completing last cannot replace a fresh cached config', async (t) => {
+  shim.setStorage({ modelName: 'older-read' })
+
+  const callbacks = []
+  const originalGet = globalThis.chrome.storage.local.get
+  t.mock.method(globalThis.chrome.storage.local, 'get', function (keys, callback) {
+    return originalGet.call(this, keys, (result) => {
+      callbacks.push(() => callback(result))
+    })
+  })
+  t.after(() => {
+    for (const callback of callbacks.splice(0)) callback()
+  })
+
+  const older = getReaderConfig()
+  await setImmediate()
+
+  // Hold the change event so both reads have the same invalidation generation.
+  shim.deferStorageEvents()
+  await setWriterConfig({ modelName: 'newer-read' })
+  const fresh = getReaderConfig({ fresh: true })
+  await setImmediate()
+  assert.equal(callbacks.length, 2, 'the fresh read must not join the older read')
+
+  callbacks.splice(1, 1)[0]()
+  assert.equal((await fresh).modelName, 'newer-read')
+  callbacks.shift()()
+  assert.equal((await older).modelName, 'older-read')
+
+  assert.equal((await getReaderConfig()).modelName, 'newer-read')
+  assert.equal(callbacks.length, 0, 'the cached result must not start another read')
+})
+
+test('an unpersisted fresh migration retires the previous cache', async (t) => {
+  shim.deferStorageEvents()
+  await setWriterConfig({ modelName: 'newer-config', claudeApiKey: 'TEST_LEGACY_SECRET' })
+  t.mock.method(globalThis.chrome.storage.local, 'set', (_items, callback) => {
+    globalThis.chrome.runtime.lastError = { message: 'quota exceeded' }
+    try {
+      callback()
+    } finally {
+      delete globalThis.chrome.runtime.lastError
+    }
+  })
+  const reads = t.mock.method(globalThis.chrome.storage.local, 'get')
+
+  assert.equal((await getReaderConfig({ fresh: true })).modelName, 'newer-config')
+  assert.equal((await getReaderConfig()).modelName, 'newer-config')
+  assert.equal(reads.mock.callCount(), 2, 'the ordinary read must retry the failed migration')
+})
+
+test('an unpersisted fresh migration prevents an older read repopulating the cache', async (t) => {
+  shim.setStorage({ modelName: 'older-read' })
+  const callbacks = []
+  const originalGet = globalThis.chrome.storage.local.get
+  t.mock.method(globalThis.chrome.storage.local, 'get', function (keys, callback) {
+    return originalGet.call(this, keys, (result) => callbacks.push(() => callback(result)))
+  })
+  t.after(() => {
+    for (const callback of callbacks.splice(0)) callback()
+  })
+  const older = getReaderConfig()
+  await setImmediate()
+  shim.deferStorageEvents()
+  await setWriterConfig({ modelName: 'newer-read', claudeApiKey: 'TEST_LEGACY_SECRET' })
+  t.mock.method(globalThis.chrome.storage.local, 'set', (_items, callback) => {
+    globalThis.chrome.runtime.lastError = { message: 'quota exceeded' }
+    try {
+      callback()
+    } finally {
+      delete globalThis.chrome.runtime.lastError
+    }
+  })
+
+  const fresh = getReaderConfig({ fresh: true })
+  await setImmediate()
+  callbacks.splice(1, 1)[0]()
+  assert.equal((await fresh).modelName, 'newer-read')
+
+  const retry = getReaderConfig()
+  await setImmediate()
+  assert.equal(callbacks.length, 2, 'retry must not reuse the older pending read')
+  callbacks.shift()()
+  assert.equal((await older).modelName, 'older-read')
+  const concurrentRetry = getReaderConfig()
+  await setImmediate()
+  assert.equal(callbacks.length, 1, 'the older completion must not clear the shared retry')
+  callbacks.shift()()
+  assert.equal((await retry).modelName, 'newer-read')
+  assert.equal((await concurrentRetry).modelName, 'newer-read')
+})
+
+test('the writer context is unaffected by holding events back', async () => {
+  shim.deferStorageEvents()
+  await setWriterConfig({ modelName: 'written-here' })
+
+  // setUserConfig invalidates its own context directly, because the event can
+  // arrive after the write resolves.
+  assert.equal((await getWriterConfig()).modelName, 'written-here')
+  shim.flushStorageEvents()
+})
+
+test('token cleanup observes a refreshed token before its storage event', async () => {
+  shim.setStorage({ accessToken: 'TEST_EXPIRED_TOKEN', tokenSavedOn: 0 })
+  await getReaderConfig()
+
+  shim.deferStorageEvents()
+  await setWriterConfig({ accessToken: 'TEST_CURRENT_TOKEN', tokenSavedOn: Date.now() })
+  await clearOldAccessToken()
+
+  assert.equal(shim.getStorage().accessToken, 'TEST_CURRENT_TOKEN')
+})
+
+// userLanguage and the default it feeds are derived from the browser locale rather
+// than stored, so a locale change has to invalidate the cache the way a write does.
+// Before the cache existed every read re-derived it, so a context that stayed alive
+// across a change used to pick the new language and now would not.
+test('a browser locale change re-derives the language', async () => {
+  const setNavigatorLanguage = (language) => {
+    Object.defineProperty(globalThis, 'navigator', {
+      value: { language, userAgent: 'Mozilla/5.0 (test)' },
+      configurable: true,
+    })
+  }
+
+  shim.setStorage({ userLanguage: 'en-US' })
+  shim.flushStorageEvents()
+  setNavigatorLanguage('en-US')
+  await getReaderConfig()
+
+  const before = await getReaderConfig()
+  assert.equal(before.userLanguage, 'en', 'derived from the locale at read time')
+
+  // The browser switches to Traditional Chinese while this context stays alive.
+  setNavigatorLanguage('zh-TW')
+  shim.dispatchGlobalEvent('languagechange')
+
+  const after = await getReaderConfig()
+  assert.equal(after.userLanguage, 'zh-Hant', 'the new locale is picked up')
+})
diff --git a/tests/unit/config/user-config-set-invalidation.test.mjs b/tests/unit/config/user-config-set-invalidation.test.mjs
new file mode 100644
index 000000000..ca62b01e1
--- /dev/null
+++ b/tests/unit/config/user-config-set-invalidation.test.mjs
@@ -0,0 +1,22 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+
+const shim = globalThis.__TEST_BROWSER_SHIM__
+
+const { getUserConfig, setUserConfig } = await import('../../../src/config/index.mjs')
+
+// Runs in its own process, and only after the import, so this drops the config
+// module's own listener. The real storage event can arrive after the write
+// resolves, so setUserConfig invalidates the cache itself; with no listener left,
+// only that explicit invalidation can keep the next read from serving the
+// previous config.
+shim.resetStorageEvents()
+
+test('setUserConfig invalidates the cache without any storage event', async () => {
+  shim.setStorage({ modelName: 'gpt-4o' })
+  assert.equal((await getUserConfig()).modelName, 'gpt-4o')
+
+  await setUserConfig({ modelName: 'gpt-4o-mini' })
+
+  assert.equal((await getUserConfig()).modelName, 'gpt-4o-mini')
+})
diff --git a/tests/unit/content-script/menu-tools.test.mjs b/tests/unit/content-script/menu-tools.test.mjs
index 22664a429..58d20796a 100644
--- a/tests/unit/content-script/menu-tools.test.mjs
+++ b/tests/unit/content-script/menu-tools.test.mjs
@@ -3,6 +3,7 @@ import { setImmediate } from 'node:timers'
 import { describe, test } from 'node:test'
 import Browser from 'webextension-polyfill'
 import { config } from '../../../src/content-script/menu-tools/index.mjs'
+import { getUserConfig } from '../../../src/config/index.mjs'
 
 function replaceBrowserMethod(t, target, name, replacement) {
   const original = target[name]
@@ -20,6 +21,29 @@ function replaceBrowserMethod(t, target, name, replacement) {
   })
 }
 
+describe('openConversationWindow', () => {
+  test('observes the creation preference before its storage event arrives', async (t) => {
+    t.mock.method(console, 'debug', () => {})
+    const shim = globalThis.__TEST_BROWSER_SHIM__
+    shim.replaceStorage({ alwaysCreateNewConversationWindow: false })
+    for (let attempt = 0; attempt < 3; attempt++) await getUserConfig()
+    shim.deferStorageEvents()
+    t.after(() => shim.flushStorageEvents())
+    shim.setStorage({ alwaysCreateNewConversationWindow: true })
+
+    replaceBrowserMethod(t, Browser.tabs, 'query', async () => [{ id: 17, windowId: 9 }])
+    const create = t.mock.fn(async () => ({ id: 10 }))
+    const update = t.mock.fn(async () => {})
+    replaceBrowserMethod(t, Browser.windows, 'create', create)
+    replaceBrowserMethod(t, Browser.windows, 'update', update)
+
+    await config.openConversationWindow.action(true)
+
+    assert.equal(create.mock.callCount(), 1)
+    assert.equal(update.mock.callCount(), 0)
+  })
+})
+
 describe('closeAllChats', () => {
   test('waits for the close message before resolving', async (t) => {
     t.mock.method(console, 'debug', () => {})
diff --git a/tests/unit/content-script/selection-toolbar-lifecycle.test.mjs b/tests/unit/content-script/selection-toolbar-lifecycle.test.mjs
index d022adb35..6d344b9f6 100644
--- a/tests/unit/content-script/selection-toolbar-lifecycle.test.mjs
+++ b/tests/unit/content-script/selection-toolbar-lifecycle.test.mjs
@@ -228,37 +228,43 @@ test('cancelling while the first mouse config read is pending prevents container
   globalThis.__SELECTION_TOOLBAR_TEST__.getUserConfig = async () => baseConfig
 })
 
-test('removing a mouse container while its render config is pending prevents render', async () => {
-  const pendingRenderConfig = deferred()
-  const createdBefore = globalThis.__SELECTION_TOOLBAR_TEST__.createdContainers.length
-  const renderedBefore = globalThis.__SELECTION_TOOLBAR_TEST__.renderCount
-  let configRead = 0
-
-  globalThis.__SELECTION_TOOLBAR_TEST__.getUserConfig = () => {
-    configRead += 1
-    if (configRead === 1) return Promise.resolve(baseConfig)
-    if (configRead === 2) return pendingRenderConfig.promise
-    return Promise.resolve(baseConfig)
+test('mouse positioning and rendering share one fresh settings snapshot', async (t) => {
+  const state = globalThis.__SELECTION_TOOLBAR_TEST__
+  const renderedBefore = state.renderCount
+  const originalGet = state.getUserConfig
+  const originalSelection = window.getSelection
+  const input = document.createElement('input')
+  document.body.append(input)
+  Object.defineProperty(input, 'offsetWidth', { value: 123 })
+  input.focus()
+  window.getSelection = () => ({
+    rangeCount: 1,
+    toString: () => 'selected text',
+    getRangeAt: () => ({ endContainer: { parentElement: document.body } }),
+  })
+  const reads = []
+  state.getUserConfig = async (options) => {
+    reads.push(options)
+    return options?.fresh ? { ...baseConfig, selectionToolsNextToInputBox: true } : baseConfig
   }
+  t.after(() => {
+    state.getUserConfig = originalGet
+    window.getSelection = originalSelection
+    input.remove()
+  })
 
-  document.body.dispatchEvent(new MouseEvent('mouseup', { bubbles: true }))
+  document.body.dispatchEvent(
+    new MouseEvent('mouseup', { bubbles: true, clientX: 20, clientY: 34 }),
+  )
   await waitFor(
-    () => globalThis.__SELECTION_TOOLBAR_TEST__.createdContainers.length === createdBefore + 1,
-    'selection toolbar container was not created',
+    () => state.renderCount === renderedBefore + 1,
+    'selection toolbar was not rendered',
   )
 
-  const container = globalThis.__SELECTION_TOOLBAR_TEST__.createdContainers.at(-1)
-  assert.equal(container.isConnected, true)
-
-  document.body.dispatchEvent(new MouseEvent('mousedown', { bubbles: true }))
-  assert.equal(container.isConnected, false)
-
-  pendingRenderConfig.resolve(baseConfig)
-  await nextTask()
-  await nextTask()
-
-  assert.equal(globalThis.__SELECTION_TOOLBAR_TEST__.renderCount, renderedBefore)
-  globalThis.__SELECTION_TOOLBAR_TEST__.getUserConfig = async () => baseConfig
+  const container = state.createdContainers.at(-1)
+  assert.equal(container.style.left, '173px')
+  assert.equal(container.style.top, '64px')
+  assert.deepEqual(reads, [{ fresh: true }])
 })
 
 test('touchstart unmounts a toolbar before removing its container', () => {
diff --git a/tests/unit/content-script/selection-tools.test.mjs b/tests/unit/content-script/selection-tools.test.mjs
index 5da9d7d97..dea9b3dc7 100644
--- a/tests/unit/content-script/selection-tools.test.mjs
+++ b/tests/unit/content-script/selection-tools.test.mjs
@@ -3,6 +3,7 @@ import assert from 'node:assert/strict'
 import { register } from 'node:module'
 import { afterEach, before, describe, test } from 'node:test'
 import { pathToFileURL } from 'node:url'
+import { getUserConfig } from '../../../src/config/index.mjs'
 
 // Register JSX/CJS loader hooks so the selection-tools module can be imported.
 register('./tests/setup/jsx-loader-hooks.mjs', pathToFileURL(process.cwd() + '/').href)
@@ -15,6 +16,7 @@ before(async () => {
 })
 
 afterEach(() => {
+  globalThis.__TEST_BROWSER_SHIM__.flushStorageEvents()
   globalThis.__TEST_BROWSER_SHIM__.clearStorage()
 })
 
@@ -22,6 +24,28 @@ afterEach(() => {
 
 const wrappedBlock = (text) => `\n'''\n${text}\n'''`
 
+test('selection prompts use fresh language even when migration writes fail', async (t) => {
+  const shim = globalThis.__TEST_BROWSER_SHIM__
+  shim.setStorage({ preferredLanguage: 'en' })
+  for (let attempt = 0; attempt < 3; attempt++) await getUserConfig()
+  shim.deferStorageEvents()
+  shim.setStorage({ preferredLanguage: 'fr', claudeApiKey: 'TEST_LEGACY_SECRET' })
+  t.mock.method(globalThis.chrome.storage.local, 'set', (_items, callback) => {
+    globalThis.chrome.runtime.lastError = { message: 'quota exceeded' }
+    try {
+      callback()
+    } finally {
+      delete globalThis.chrome.runtime.lastError
+    }
+  })
+
+  const fresh = await getUserConfig({ fresh: true })
+  assert.equal(fresh.preferredLanguage, 'fr')
+  assert.equal((await getUserConfig()).preferredLanguage, 'fr')
+  assert.ok((await config.explain.genPrompt('passage', fresh)).startsWith('Reply in French'))
+  assert.ok((await config.explain.genPrompt('passage')).startsWith('Reply in French'))
+})
+
 // ── basic genPrompt output for every tool ────────────────────────────
 
 describe('selection-tools genPrompt', () => {
diff --git a/tests/unit/services/apis/chatgpt-web-config.test.mjs b/tests/unit/services/apis/chatgpt-web-config.test.mjs
new file mode 100644
index 000000000..676c941f5
--- /dev/null
+++ b/tests/unit/services/apis/chatgpt-web-config.test.mjs
@@ -0,0 +1,120 @@
+import assert from 'node:assert/strict'
+import { beforeEach, test } from 'node:test'
+import { register } from 'node:module'
+import { getUserConfig } from '../../../../src/config/index.mjs'
+
+register(new URL('../../../setup/chatgpt-web-loader-hooks.mjs', import.meta.url))
+const {
+  getModels,
+  getRequirements,
+  isNeedWebsocket,
+  sendWebsocketConversation,
+  stopWebsocketConversation,
+  deleteConversation,
+} = await import('../../../../src/services/apis/chatgpt-web.mjs')
+
+const shim = globalThis.__TEST_BROWSER_SHIM__
+
+beforeEach(async () => {
+  shim.flushStorageEvents()
+  shim.replaceStorage({ customChatGptWebApiUrl: 'https://old.example' })
+  for (let attempt = 0; attempt < 3; attempt++) await getUserConfig()
+})
+
+test('ChatGPT Web requests observe endpoint changes before their storage event', async (t) => {
+  shim.deferStorageEvents()
+  t.after(() => shim.flushStorageEvents())
+  shim.setStorage({ customChatGptWebApiUrl: 'https://new.example' })
+  const fetch = t.mock.method(globalThis, 'fetch', async () => ({
+    text: async () => JSON.stringify({ models: [{ slug: 'TEST_MODEL' }] }),
+  }))
+  t.mock.method(console, 'debug', () => {})
+
+  assert.deepEqual(await getModels('TEST_TOKEN'), ['TEST_MODEL'])
+  assert.equal(fetch.mock.calls[0].arguments[0], 'https://new.example/backend-api/models')
+})
+
+test('websocket requests observe endpoint updates before storage events', async (t) => {
+  shim.deferStorageEvents()
+  t.after(() => shim.flushStorageEvents())
+  shim.setStorage({ customChatGptWebApiUrl: 'https://new.example' })
+  const fetch = t.mock.method(globalThis, 'fetch', async () => ({
+    json: async () => ({
+      conversation_id: 'TEST_CONVERSATION',
+      websocket_request_id: 'TEST_REQUEST',
+    }),
+  }))
+  t.mock.method(console, 'debug', () => {})
+
+  const result = await sendWebsocketConversation('TEST_TOKEN', { method: 'POST' })
+
+  assert.equal(fetch.mock.calls[0].arguments[0], 'https://new.example/backend-api/conversation')
+  assert.equal(result.conversationId, 'TEST_CONVERSATION')
+  assert.equal(result.wsRequestId, 'TEST_REQUEST')
+})
+
+test('conversation cleanup keeps the generation endpoint after settings change', async (t) => {
+  const snapshot = await getUserConfig({ fresh: true })
+  shim.setStorage({ customChatGptWebApiUrl: 'https://new.example' })
+  const reads = t.mock.method(globalThis.chrome.storage.local, 'get')
+  const fetch = t.mock.method(globalThis, 'fetch', async () => ({ text: async () => '{}' }))
+  t.mock.method(console, 'debug', () => {})
+
+  await stopWebsocketConversation('TEST_TOKEN', 'TEST_CONVERSATION', 'TEST_REQUEST', snapshot)
+  await deleteConversation('TEST_TOKEN', 'TEST_CONVERSATION', snapshot)
+
+  assert.equal(reads.mock.callCount(), 0)
+  assert.deepEqual(
+    fetch.mock.calls.map((call) => call.arguments[0]),
+    [
+      'https://old.example/backend-api/stop_conversation',
+      'https://old.example/backend-api/conversation/TEST_CONVERSATION',
+    ],
+  )
+})
+
+test('ChatGPT Web subrequests reuse config without storage reads', async (t) => {
+  const reads = t.mock.method(globalThis.chrome.storage.local, 'get')
+  const fetch = t.mock.method(globalThis, 'fetch', async () => ({
+    text: async () => JSON.stringify({ models: [{ slug: 'TEST_MODEL' }], shared_websocket: true }),
+  }))
+  t.mock.method(console, 'debug', () => {})
+  const snapshot = { customChatGptWebApiUrl: 'https://snapshot.example' }
+
+  await Promise.all([
+    getModels('TEST_TOKEN', snapshot),
+    getRequirements('TEST_TOKEN', snapshot),
+    isNeedWebsocket('TEST_TOKEN', snapshot),
+  ])
+
+  assert.equal(reads.mock.callCount(), 0)
+  assert.equal(fetch.mock.callCount(), 3)
+  assert.ok(
+    fetch.mock.calls.every((call) => call.arguments[0].startsWith('https://snapshot.example/')),
+  )
+})
+
+test('websocket conversation requests reuse a supplied config snapshot', async (t) => {
+  const reads = t.mock.method(globalThis.chrome.storage.local, 'get')
+  const fetch = t.mock.method(globalThis, 'fetch', async () => ({
+    json: async () => ({
+      conversation_id: 'TEST_CONVERSATION',
+      websocket_request_id: 'TEST_REQUEST',
+    }),
+  }))
+  t.mock.method(console, 'debug', () => {})
+
+  await sendWebsocketConversation(
+    'TEST_TOKEN',
+    { method: 'POST' },
+    {
+      customChatGptWebApiUrl: 'https://snapshot.example',
+    },
+  )
+
+  assert.equal(reads.mock.callCount(), 0)
+  assert.equal(
+    fetch.mock.calls[0].arguments[0],
+    'https://snapshot.example/backend-api/conversation',
+  )
+})
diff --git a/tests/unit/services/wrappers-register.test.mjs b/tests/unit/services/wrappers-register.test.mjs
index cfee3e4f7..ab35450a5 100644
--- a/tests/unit/services/wrappers-register.test.mjs
+++ b/tests/unit/services/wrappers-register.test.mjs
@@ -45,6 +45,7 @@ import {
   getClaudeSessionKey,
 } from '../../../src/services/wrappers.mjs'
 import Browser from 'webextension-polyfill'
+import { getUserConfig } from '../../../src/config/index.mjs'
 import { normalizeApiMode } from '../../../src/utils/model-name-convert.mjs'
 import { FETCH_REQUEST_FAILED } from '../../../src/utils/fetch-sse.mjs'
 import { formatErrorMessage } from '../../../src/utils/error-text.mjs'
@@ -116,6 +117,55 @@ test('registerPortListener calls executor with session, port, and config', async
   assert.equal(port.postedMessages[0].session, result.session)
 })
 
+test('registerPortListener observes settings written before their storage event', async (t) => {
+  t.mock.method(console, 'debug', () => {})
+  const shim = globalThis.__TEST_BROWSER_SHIM__
+  setStorage({ modelName: 'chatgptApi6_1Sol' })
+  for (let attempt = 0; attempt < 3; attempt++) await getUserConfig()
+
+  shim.deferStorageEvents()
+  t.after(() => shim.flushStorageEvents())
+  shim.setStorage({ modelName: 'claudeSonnet55Api', preferredLanguage: 'fr' })
+
+  let resolveExec
+  const execDone = new Promise((resolve) => {
+    resolveExec = resolve
+  })
+  registerPortListener(async (session, _port, config) => {
+    resolveExec({ session, config })
+  })
+  const port = createFakePort()
+  triggerConnect(port)
+  port.emitMessage({ session: { conversationRecords: [] } })
+  const { session, config } = await execDone
+
+  assert.equal(session.modelName, 'claudeSonnet55Api')
+  assert.equal(config.preferredLanguage, 'fr')
+})
+
+test('registerPortListener reports config-read errors before execution', async (t) => {
+  t.mock.method(console, 'debug', () => {})
+  t.mock.method(console, 'error', () => {})
+  t.mock.method(globalThis.chrome.storage.local, 'get', (_keys, callback) => {
+    globalThis.chrome.runtime.lastError = { message: 'storage unavailable' }
+    try {
+      callback(undefined)
+    } finally {
+      delete globalThis.chrome.runtime.lastError
+    }
+  })
+  const executor = t.mock.fn(async () => {})
+  registerPortListener(executor)
+  const port = createFakePort()
+  triggerConnect(port)
+  const errorPosted = waitForPortError(port)
+
+  port.emitMessage({ session: { conversationRecords: [] } })
+
+  assert.match(await errorPosted, /storage unavailable/)
+  assert.equal(executor.mock.callCount(), 0)
+})
+
 test('registerPortListener scopes error translations to each request', async (t) => {
   t.mock.method(console, 'debug', () => {})
   t.mock.method(console, 'error', () => {})
diff --git a/tests/unit/setup/browser-shim.test.mjs b/tests/unit/setup/browser-shim.test.mjs
index 273f9c0ef..9840e6125 100644
--- a/tests/unit/setup/browser-shim.test.mjs
+++ b/tests/unit/setup/browser-shim.test.mjs
@@ -18,6 +18,15 @@ beforeEach(() => {
   globalThis.__TEST_BROWSER_SHIM__.clearStorage()
 })
 
+test('storage.local.get returns a promise when callback is omitted', async () => {
+  globalThis.__TEST_BROWSER_SHIM__.setStorage({ requested: 'stored-value' })
+
+  const result = globalThis.chrome.storage.local.get('requested')
+
+  assert.equal(typeof result.then, 'function')
+  assert.deepEqual(await result.then((value) => value), { requested: 'stored-value' })
+})
+
 test('storage.local.get with object keys returns only requested keys and uses defaults', async () => {
   globalThis.__TEST_BROWSER_SHIM__.replaceStorage({
     requested: 'stored-value',
@@ -149,3 +158,92 @@ test('runtime.sendMessage returns a resolved promise when callback is omitted',
 
   assert.equal(result, undefined)
 })
+
+const recordStorageChanges = () => {
+  const areaChanges = []
+  const globalChanges = []
+  const onAreaChanged = (changes) => areaChanges.push(changes)
+  const onGlobalChanged = (changes, areaName) => globalChanges.push([changes, areaName])
+  globalThis.chrome.storage.local.onChanged.addListener(onAreaChanged)
+  globalThis.chrome.storage.onChanged.addListener(onGlobalChanged)
+  return {
+    areaChanges,
+    globalChanges,
+    stop() {
+      globalThis.chrome.storage.local.onChanged.removeListener(onAreaChanged)
+      globalThis.chrome.storage.onChanged.removeListener(onGlobalChanged)
+    },
+  }
+}
+
+test('storage events report changed keys on both storage events', () => {
+  const shim = globalThis.__TEST_BROWSER_SHIM__
+  shim.setStorage({ alpha: 1 })
+  const recorded = recordStorageChanges()
+
+  shim.setStorage({ alpha: 2, beta: { nested: true } })
+
+  recorded.stop()
+  assert.deepEqual(recorded.areaChanges, [
+    {
+      alpha: { oldValue: 1, newValue: 2 },
+      beta: { oldValue: undefined, newValue: { nested: true } },
+    },
+  ])
+  assert.deepEqual(recorded.globalChanges, [[recorded.areaChanges[0], 'local']])
+})
+
+test('storage events skip keys whose value did not change', () => {
+  const shim = globalThis.__TEST_BROWSER_SHIM__
+  shim.setStorage({ alpha: 1, beta: [1, 2] })
+  const recorded = recordStorageChanges()
+
+  // Chromium compares by value, so a new object with identical content is not a
+  // change and no event is reported for it.
+  shim.setStorage({ alpha: 1, beta: [1, 2] })
+  globalThis.chrome.storage.local.remove('missing-key')
+
+  recorded.stop()
+  assert.deepEqual(recorded.areaChanges, [])
+})
+
+test('storage events report keys added and removed with undefined values', () => {
+  const shim = globalThis.__TEST_BROWSER_SHIM__
+  shim.setStorage({ present: undefined })
+  const recorded = recordStorageChanges()
+
+  globalThis.chrome.storage.local.remove('present')
+
+  recorded.stop()
+  assert.deepEqual(recorded.areaChanges, [
+    { present: { oldValue: undefined, newValue: undefined } },
+  ])
+})
+
+test('fireUnchangedKeys reports only the written keys, like Firefox', () => {
+  const shim = globalThis.__TEST_BROWSER_SHIM__
+  shim.setStorage({ untouched: 'stored', rewritten: 'before' })
+  const recorded = recordStorageChanges()
+
+  shim.setStorage({ rewritten: 'before', added: 'new' }, { fireUnchangedKeys: true })
+
+  recorded.stop()
+  assert.deepEqual(Object.keys(recorded.areaChanges[0]).sort(), ['added', 'rewritten'])
+})
+
+test('disabling storage-event deferral preserves pending notifications', (t) => {
+  const shim = globalThis.__TEST_BROWSER_SHIM__
+  const recorded = recordStorageChanges()
+  t.after(() => {
+    shim.flushStorageEvents()
+    recorded.stop()
+  })
+  shim.deferStorageEvents()
+  shim.setStorage({ deferred: 'stored' })
+  shim.deferStorageEvents(false)
+
+  assert.equal(shim.pendingStorageEvents(), 1)
+  assert.equal(recorded.areaChanges.length, 0)
+  assert.equal(shim.flushStorageEvents(), 1)
+  assert.equal(recorded.areaChanges[0].deferred.newValue, 'stored')
+})