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')
+})