// ==UserScript==
// @name         ChatGPT模型选择器增强
// @namespace    http://tampermonkey.net/
// @author       schweigen
// @version      2.5.0
// @description  增强 Main 模型选择器（黏性重排、防抖动、自定义项、丝滑切换、隐藏分组与Legacy）；并集成“使用其他模型重试的模型选择器”快捷项与30秒强制模型窗口（自动触发原生项或重试）；可以自定义模型顺序。特别鸣谢:attention1111(linux.do)，gpt-5；已适配 ChatGPT Atlas
// @match        https://chatgpt.com/*
// @match        https://chatgpt.com/?model=*
// @match        https://chatgpt.com/?temporary-chat=*
// @match        https://chatgpt.com/c/*
// @match        https://chatgpt.com/g/*
// @match        https://chatgpt.com/share/*
// @run-at       document-start
// @grant        GM_getValue
// @grant        GM_setValue
// @grant        GM_registerMenuCommand
// @license      MIT
// @downloadURL none
// ==/UserScript==

(() => {
  'use strict';
  const W = typeof unsafeWindow !== 'undefined' ? unsafeWindow : window;
  // 日志工具
  const FM = (() => {
    const prefix = '[fm]';
    const safe = (fn, ...a) => { try { fn(prefix, ...a); } catch {} };
    return {
      log:  (...a) => safe(console.log,  ...a),
      info: (...a) => safe(console.info, ...a),
      warn: (...a) => safe(console.warn, ...a),
      error:(...a) => safe(console.error,...a),
    };
  })();

  // schweigen said: 老虎机版vibe coding，我都不知道我在写什么，纯屎山，勿喷 :D
  // 特别鸣谢:attention1111(linux.do)，gpt-5
  // 现状说明：
  // 1) 临时聊天（temporary-chat）暂时无法增强“使用其他模型重试的模型选择器”。
  // 2) Projects 中目前官方没有“重试”按钮，笔者太菜不知道怎么添加能抗住遥测的retry按钮。
  // ========= 概览：本脚本处理“两个不同的菜单”并采用不同匹配/放置策略 =========
  // 1) Main 模型选择器（Main Model Switcher）
  //    - 匹配条件：
  //      role="menu" | "listbox"，且包含 Main 菜单签名 [data-testid^="model-switcher-"] 或 [data-cgpt-turn]；
  //      同时不包含“重试模型选择器”关键字（Auto/Instant/Thinking/Pro/Ultra）。
  //    - 放置策略：
  //      若无同名原生项，则在“最后一个 GPT‑5 原生项”之后插入自定义项，随后用 applyDesiredOrder 按订阅层级的目标顺序黏性重排。
  //      并隐藏“Legacy models”相关入口/分隔线，尽量减少 hover 抖动和菜单关闭。
  //    - 点击行为：
  //      自定义项阻止冒泡后，先做“丝滑更新”（URL+按钮文案），再尝试点击同 id 的原生项，让后端状态切换。
  //
  // 2) 使用其他模型重试的模型选择器（Auto/Instant/Thinking(mini)/Pro/Ultra(Think)）
  //    - 匹配条件：
  //      菜单内出现上述关键字，且不含 Main 菜单签名（与 Main 模型选择器互斥）。
  //    - 放置策略：
  //      以锚点项为参照（优先 o4 mini / gpt‑4o / gpt‑4.1，找不到则取第一项），在其后插入 4 个快捷项：
  //      o3 pro、GPT 5 mini、o4 mini high、GPT 4.5（按订阅层级可能被隐藏）。
  //    - 点击行为：
  //      点击快捷项会 setForce(model, 2000) 开启 2 秒的强制模型窗口，随后优先触发原生菜单项；
  //      若没有，则回退点击“重试/Regenerate”。期间 fetch 改写会把会话请求中的 model 重写为强制模型。
  //
  // 触发与监听：
  // - 入口按钮：[data-testid="model-switcher-dropdown-button"]。首次点击时，对其关联菜单安装观察器；
  //   全局还注册一个 MutationObserver 作为兜底：发现任意新菜单后按类型路由到对应处理逻辑。
  // - 其它：通过 Analytics 的“Model Switcher”事件同步顶部按钮文案；URL 的 ?model= 同步到按钮；样式上隐藏 legacy 分隔线。

  // ---------------- 配置 ----------------
  const TEST_ID_SWITCHER = 'model-switcher-dropdown-button';
  // 订阅层级存储键与默认值
  const SUB_KEY = 'chatgpt-subscription-tier';
  const SUB_DEFAULT = 'plus';
  const SUB_LEVELS = ['free','go','k12','plus','team','edu','enterprise','pro','test'];

  function normalizeTierKey(tier) {
    const raw = (tier || '').toString().trim().toLowerCase();
    if (!raw) return '';
    const key = raw.replace(/\s+/g, '-');
    const aliases = {
      'k12-teacher': 'k12',
      'k12teacher': 'k12',
    };
    const mapped = aliases[key] || key;
    return SUB_LEVELS.includes(mapped) ? mapped : '';
  }

  function gmGet(key, defVal = undefined) {
    try { if (typeof GM_getValue === 'function') return GM_getValue(key, defVal); } catch {}
    try {
      const raw = localStorage.getItem(key);
      return raw == null ? defVal : JSON.parse(raw);
    } catch { return defVal; }
  }
  function gmSet(key, val) {
    try { if (typeof GM_setValue === 'function') return GM_setValue(key, val); } catch {}
    try { localStorage.setItem(key, JSON.stringify(val)); } catch {}
  }
  function getTier() {
    return normalizeTierKey(gmGet(SUB_KEY, ''));
  }
  function setTier(tier) {
    const norm = normalizeTierKey(tier);
    if (!norm) return;
    gmSet(SUB_KEY, norm);
  }
  function tierPromptText() {
    return '请选择订阅层级（仅出现一次，之后可在油猴菜单重新选择；不区分大小写）：\n' +
      'free / go / k12 / plus / team / edu / enterprise / pro / test\n\n' +
      '提示：若选错，可在油猴脚本菜单点击“重新选择订阅层级”。';
  }
  function chooseTierInteractively(defaultTier = SUB_DEFAULT, silent = false) {
    while (true) {
      const inputRaw = window.prompt(tierPromptText(), defaultTier);
      if (inputRaw == null) {
        const chosen = normalizeTierKey(defaultTier) || SUB_DEFAULT;
        setTier(chosen);
        if (!silent) { try { location.reload(); } catch {} }
        return chosen;
      }
      const input = normalizeTierKey(inputRaw);
      if (!input) {
        try { alert('订阅层级无效，请重新输入'); } catch {}
        continue;
      }
      setTier(input);
      if (!silent) {
        try {
          let msg = '已设置订阅层级：' + input;
          switch (input) {
            case 'edu':
              msg += '\n\n重要：edu 套餐的拓展模型如果无法在主页面使用，请前往 Projects 中使用。**且**用户必须在设置里开启“启用更多模型/老模型”。';
              break;
            case 'plus':
              msg += '\n\n重要：必须在设置里开启“启用更多模型/老模型”，才能使用老模型';
              break;
            case 'team':
              msg += '\n\n重要：必须让 team**所有者/管理者** 在设置中开启“启用更多模型/老模型”，**且**用户必须在设置里开启“启用更多模型/老模型”，才能使用老模型';
              break;
            case 'enterprise':
              msg += '\n\n重要：必须让企业**所有者/管理者** 在设置中开启“启用更多模型/老模型”，**且**用户必须在设置里开启“启用更多模型/老模型”，才能使用老模型。拓展模型如果无法在主页面使用，请前往 Projects 中使用。';
              break;
            case 'pro':
              msg += '\n\n重要：如果无法使用老模型，可以看下设置里有没有开启“启用更多模型/老模型”';
              break;
            case 'test':
              msg += '\n\n提示：test 订阅仅供测试用途，仅在本脚本内生效。';
              break;
          }
          alert(msg);
        } catch {}
      }
      if (!silent) { try { location.reload(); } catch {} }
      return input;
    }
  }
  function ensureTierChosen() {
    const t = getTier();
    if (!t) return chooseTierInteractively(SUB_DEFAULT, false);
    return t;
  }

  // 注册“重新选择订阅层级”菜单
  try {
    if (typeof GM_registerMenuCommand === 'function') {
      const currentTierForMenu = getTier() || '未设置';
      GM_registerMenuCommand(`模型选择器设置（现在：${currentTierForMenu}）`, () => openSettingsPanel());
    }
  } catch {}

  // 默认目标顺序（按 data-testid 后缀）
  // 目标顺序（含 5.2 替换）：
  // - 用 gpt-5-2-* 取代旧 gpt-5.1/5 非 Pro 系列在主菜单中的位置
  // - 旧 gpt-5.1/5 系列统一降到末尾
  const BASE_ORDER = [
    'gpt-5-2-thinking',
    // 原先紧随其后的“旧 5.x Thinking Mini/Instant/Auto/mini”位置由 5.2 系列承接
    'gpt-5-2-instant',
    'gpt-5-2',
    'gpt-5-2-pro',
    'o3',
    'o4-mini',
    'gpt-4o',
    'gpt-4-1',
    'gpt-4-5',
    'chatgpt_alpha_model_external_access_reserved_gate_13',
  ];
  const PRO_PRIORITY_ORDER = [
    'gpt-5-2-thinking',
    'o4-mini',
    'gpt-4-5',
    'gpt-5-2-pro',
    'o3-pro',
  ];
  const TEST_ONLY_MODELS = ['gpt-5-1-max-thinking', 'gpt-5-1-max'];
  // 旧 5.1/5 系列降序列（按用户指定顺序）
  const DEMOTED_OLD_G5 = [
    'gpt-5-1-pro',
    'gpt-5-pro',
    'gpt-5-1-thinking',
    'gpt-5-thinking',
    'gpt-5-1-instant',
    'gpt-5-instant',
    // 其他旧 5.x 变体继续置底
    'gpt-5-t-mini',
    'gpt-5-mini',
  ];

  // 自定义排序（按订阅层级分别保存）
  const ORDER_KEY_PREFIX = 'fm-custom-model-order-v1:';
  const getOrderKey = (tier) => `${ORDER_KEY_PREFIX}${normalizeTierKey(tier) || 'unknown'}`;
  function getCustomOrderForTier(tier) {
    const raw = gmGet(getOrderKey(tier), []);
    if (!Array.isArray(raw)) return [];
    const out = [];
    const seen = new Set();
    for (const x of raw) {
      const id = normalizeModelId(x);
      if (!id || seen.has(id)) continue;
      seen.add(id);
      out.push(id);
    }
    return out;
  }
  function setCustomOrderForTier(tier, list) {
    const out = [];
    const seen = new Set();
    for (const x of (Array.isArray(list) ? list : [])) {
      const id = normalizeModelId(x);
      if (!id || seen.has(id)) continue;
      seen.add(id);
      out.push(id);
    }
    gmSet(getOrderKey(tier), out);
  }
  function clearCustomOrderForTier(tier) {
    gmSet(getOrderKey(tier), []);
  }

  // 自定义隐藏模型（按订阅层级分别保存）
  const HIDE_KEY_PREFIX = 'fm-hidden-models-v1:';
  const getHideKey = (tier) => `${HIDE_KEY_PREFIX}${normalizeTierKey(tier) || 'unknown'}`;
  const HIDDEN_CACHE = new Map(); // tier -> Set<modelId>
  function getHiddenModelSetForTier(tier) {
    const t = normalizeTierKey(tier) || 'unknown';
    if (HIDDEN_CACHE.has(t)) return HIDDEN_CACHE.get(t);
    const raw = gmGet(getHideKey(t), []);
    const set = new Set();
    if (Array.isArray(raw)) {
      for (const x of raw) {
        const id = normalizeModelId(x);
        if (!id) continue;
        set.add(id);
      }
    }
    HIDDEN_CACHE.set(t, set);
    return set;
  }
  function setHiddenModelsForTier(tier, list) {
    const t = normalizeTierKey(tier) || 'unknown';
    const out = [];
    const set = new Set();
    for (const x of (Array.isArray(list) ? list : [])) {
      const id = normalizeModelId(x);
      if (!id || set.has(id)) continue;
      set.add(id);
      out.push(id);
    }
    gmSet(getHideKey(t), out);
    HIDDEN_CACHE.set(t, set);
  }
  function clearHiddenModelsForTier(tier) {
    const t = normalizeTierKey(tier) || 'unknown';
    gmSet(getHideKey(t), []);
    HIDDEN_CACHE.set(t, new Set());
  }
  function isModelHiddenForTier(id, tier) {
    const norm = normalizeModelId(id);
    if (!norm) return false;
    return getHiddenModelSetForTier(tier).has(norm);
  }
  function isModelHidden(id) {
    return isModelHiddenForTier(id, getTier() || SUB_DEFAULT);
  }
  function mergeOrderWithCustom(baseOrder, customOrder) {
    const result = [];
    const seen = new Set();
    for (const id of (Array.isArray(customOrder) ? customOrder : [])) {
      const norm = normalizeModelId(id);
      if (!norm || seen.has(norm)) continue;
      seen.add(norm);
      result.push(norm);
    }
    for (const id of (Array.isArray(baseOrder) ? baseOrder : [])) {
      const norm = normalizeModelId(id);
      if (!norm || seen.has(norm)) continue;
      seen.add(norm);
      result.push(norm);
    }
    return result;
  }

  function getBaseDesiredOrderForTier(tier) {
    const t = normalizeTierKey(tier) || SUB_DEFAULT;
    if (t === 'pro') {
      const seen = new Set();
      const pushUnique = (arr, target) => {
        for (const id of arr) {
          const norm = normalizeModelId(id);
          if (!norm || seen.has(norm)) continue;
          seen.add(norm);
          target.push(norm);
        }
      };
      const result = [];
      pushUnique(PRO_PRIORITY_ORDER, result);
      pushUnique(BASE_ORDER, result);
      pushUnique(DEMOTED_OLD_G5, result);
      // 最后追加 test 分组
      pushUnique(TEST_GROUP_ORDER, result);
      return result;
    }
    // 非 pro：gpt-5-2-thinking 第一，α 第二，其余保持当前顺序
    const ALPHA_ID = 'chatgpt_alpha_model_external_access_reserved_gate_13';
    const FIRST_ID = 'gpt-5-2-thinking';
    const rest = BASE_ORDER.filter(id => id !== FIRST_ID && id !== ALPHA_ID);
    return [FIRST_ID, ALPHA_ID, ...rest, ...DEMOTED_OLD_G5, ...TEST_GROUP_ORDER].map(normalizeModelId);
  }

  function getDesiredOrder() {
    const tier = getTier() || SUB_DEFAULT;
    const base = getBaseDesiredOrderForTier(tier);
    const custom = getCustomOrderForTier(tier);
    const hidden = getHiddenModelSetForTier(tier);
    return mergeOrderWithCustom(base, custom).filter(id => !hidden.has(id));
  }
  const ALT_IDS = { 'gpt-4-1': ['gpt-4.1'], 'gpt-4-5': ['gpt-4.5'] };

  // 点击后不自动收起菜单的模型（硬编码名单）
  const NO_CLOSE_ON_CHOOSE_IDS = new Set([
    // 5.2 系列
    'gpt-5-2',
    'gpt-5-2-instant',
    'gpt-5-2-thinking',
    'gpt-5-2-pro',
    // 旧 5.x 系列（保持“不自动收起”体验）
    'gpt-5-instant',
    'gpt-5-thinking',
    'gpt-5-pro',
    'gpt-5-t-mini',
    'gpt-5-mini',
    'gpt-5-1-instant',
    'gpt-5-1-thinking',
    'gpt-5-1-pro',
    'gpt-5-1-max',
    'gpt-5-1-max-thinking',
  ]);

  // 自定义模型项（若该菜单已经有官方同名项则不重复插入）
  const CUSTOM_MODELS = [
    { id: 'o3',           label: 'o3' },
    { id: 'o3-pro',       label: 'o3 pro' },
    { id: 'gpt-4-1',      label: 'GPT 4.1' },
    { id: 'gpt-4o',       label: 'GPT 4o' },
    { id: 'o4-mini',      label: 'o4 mini' },
    // 新增 5.2 系列（替代旧 5.1/5 非 Pro）
    { id: 'gpt-5-2',          label: 'GPT 5.2 Auto' },
    { id: 'gpt-5-2-instant',  label: 'GPT 5.2 Instant' },
    { id: 'gpt-5-2-thinking', label: 'GPT 5.2 Thinking' },
    { id: 'gpt-5-2-pro',      label: 'GPT 5.2 Pro' },

    // 旧 5.1 系列（无无后缀版，仅保留变体/测试项）
    { id: 'gpt-5-1-instant',    label: 'GPT 5.1 Instant' },
    { id: 'gpt-5-1-thinking',   label: 'GPT 5.1 Thinking' },
    { id: 'gpt-5-1-pro',        label: 'GPT 5.1 Pro' },
    { id: 'gpt-5-1-max',        label: 'GPT 5.1 Max' },
    { id: 'gpt-5-1-max-thinking', label: 'GPT 5.1 Max Thinking' },

    // 旧 5 系列（无无后缀版，保留变体/mini）
    { id: 'gpt-5-instant',  label: 'GPT 5 Instant' },
    { id: 'gpt-5-t-mini',   label: 'GPT 5 Thinking Mini' },
    { id: 'gpt-5-mini',     label: 'GPT 5 mini' },
    { id: 'gpt-5-thinking', label: 'GPT 5 Thinking' },
    { id: 'gpt-5-pro',      label: 'GPT 5 Pro' },
    { id: 'gpt-4-5',      label: 'GPT 4.5' },
    { id: 'chatgpt_alpha_model_external_access_reserved_gate_13', label: 'α' },
  ];

  const TEST_ONLY_MODEL_SET = new Set(TEST_ONLY_MODELS);

  // ---------------- 订阅层级可用性（按表格矩阵；忽略次数，仅判断可选/不可选） ----------------
  const MODEL_GROUP = Object.freeze({
    G5_PRO: 'g5_pro',          // gpt-5.2/5.1/5-pro（共享）
    O3_PRO: 'o3_pro',
    GPT_4_5: 'gpt_4_5',
    G5_THINKING: 'g5_thinking',// gpt-5.2/5.1/5-thinking（共享，含 route 到的）
    O3: 'o3',
    G5_INSTANT: 'g5_instant',  // gpt-5.2/5.1/5-instant（共享，含 route 到的；含 Auto）
    G5_T_MINI: 'g5_t_mini',
    O4_MINI: 'o4_mini',
    GPT_4O: 'gpt_4o',
    GPT_4_1: 'gpt_4_1',
    G5_MINI: 'g5_mini',
  });

  // 未列入矩阵的“未知模型”默认策略：
  // - free/go/k12：严格，仅允许矩阵内列出的模型
  // - plus/team/edu/enterprise/pro：宽松，未知模型默认放行（避免误伤新模型）
  const STRICT_TIERS = new Set(['free', 'go', 'k12']);
  // free/go/k12/plus 都没有任何 *-pro（包括 o3-pro、gpt-5-2-pro 等）
  const NO_PRO_TIERS = new Set(['free', 'go', 'k12', 'plus']);

  const TEAM_LIKE = [
    MODEL_GROUP.G5_PRO,
    MODEL_GROUP.G5_THINKING,
    MODEL_GROUP.G5_INSTANT,
    MODEL_GROUP.G5_T_MINI,
    MODEL_GROUP.O3,
    MODEL_GROUP.O4_MINI,
    MODEL_GROUP.GPT_4O,
    MODEL_GROUP.GPT_4_1,
    MODEL_GROUP.G5_MINI,
  ];

  const TIER_ALLOWED_GROUPS = {
    free: new Set([MODEL_GROUP.G5_THINKING, MODEL_GROUP.G5_INSTANT, MODEL_GROUP.G5_T_MINI, MODEL_GROUP.G5_MINI]),
    go: new Set([MODEL_GROUP.G5_THINKING, MODEL_GROUP.G5_INSTANT, MODEL_GROUP.G5_T_MINI, MODEL_GROUP.G5_MINI]),
    k12: new Set([MODEL_GROUP.G5_THINKING, MODEL_GROUP.G5_INSTANT, MODEL_GROUP.G5_MINI]),
    plus: new Set([
      MODEL_GROUP.G5_THINKING,
      MODEL_GROUP.G5_INSTANT,
      MODEL_GROUP.G5_T_MINI,
      MODEL_GROUP.O3,
      MODEL_GROUP.O4_MINI,
      MODEL_GROUP.GPT_4O,
      MODEL_GROUP.GPT_4_1,
      MODEL_GROUP.G5_MINI,
    ]),
    team: new Set(TEAM_LIKE),
    edu: new Set(TEAM_LIKE),
    enterprise: new Set(TEAM_LIKE),
    pro: new Set(Object.values(MODEL_GROUP)),
  };

  function getModelGroupById(norm) {
    if (!norm) return '';
    if (norm === 'o3-pro') return MODEL_GROUP.O3_PRO;
    if (norm === 'gpt-4-5') return MODEL_GROUP.GPT_4_5;
    if (norm === 'o3') return MODEL_GROUP.O3;
    if (norm === 'o4-mini') return MODEL_GROUP.O4_MINI;
    if (norm === 'gpt-4o') return MODEL_GROUP.GPT_4O;
    if (norm === 'gpt-4-1') return MODEL_GROUP.GPT_4_1;
    if (norm === 'gpt-5-t-mini') return MODEL_GROUP.G5_T_MINI;
    if (norm === 'gpt-5-mini') return MODEL_GROUP.G5_MINI;

    // gpt-5 系列（含 5 / 5.1 / 5.2）
    if (/^gpt-5(?:-2|-1)?-pro$/.test(norm)) return MODEL_GROUP.G5_PRO;
    if (/^gpt-5(?:-2|-1)?-thinking$/.test(norm)) return MODEL_GROUP.G5_THINKING;
    if (/^gpt-5(?:-2|-1)?-instant$/.test(norm)) return MODEL_GROUP.G5_INSTANT;
    if (/^gpt-5(?:-2|-1)?$/.test(norm)) return MODEL_GROUP.G5_INSTANT; // Auto（无后缀）
    return '';
  }

  function isModelAllowedForTier(id, tier) {
    const norm = normalizeModelId(id);
    const t = normalizeTierKey(tier) || SUB_DEFAULT;
    if (TEST_ONLY_MODEL_SET.has(norm)) return t === 'test';
    if (t === 'test') return true;

    // 统一规则：free/go/k12/plus 都没有任何 *-pro
    if (NO_PRO_TIERS.has(t) && norm.endsWith('-pro')) return false;

    const group = getModelGroupById(norm);
    if (!group) return !STRICT_TIERS.has(t);
    const allowed = TIER_ALLOWED_GROUPS[t];
    if (!allowed) return true;
    return allowed.has(group);
  }

  function isModelAllowed(id) {
    return isModelAllowedForTier(id, getTier() || SUB_DEFAULT);
  }

  // ---------------- 工具 ----------------
  const debounce = (fn, wait = 50) => { let t; return (...a) => { clearTimeout(t); t = setTimeout(() => fn.apply(null, a), wait); }; };

  // 标准化与美化名称
  const CUSTOM_NAME_MAP = new Map(CUSTOM_MODELS.map(m => [m.id.toLowerCase(), m.label]));
  const EXTRA_NAME_MAP = new Map(Object.entries({
    'gpt-4o': 'GPT 4o',
    'gpt-4-1': 'GPT 4.1',
    'gpt-4.1': 'GPT 4.1',
    'gpt-4-5': 'GPT 4.5',
    'o3': 'o3',
    'o3-pro': 'o3 pro',
    'o4-mini': 'o4 mini',
    'gpt-5': 'GPT 5 Auto',
    'gpt-5-instant': 'GPT 5 Instant',
    'gpt-5-t-mini': 'GPT 5 Thinking Mini',
    'gpt-5-thinking': 'GPT 5 Thinking',
    'gpt-5-pro': 'GPT 5 Pro',
    'gpt-5-mini': 'GPT 5 mini',
    // 5.2 系列显示名
    'gpt-5-2': 'GPT 5.2 Auto',
    'gpt-5-2-instant': 'GPT 5.2 Instant',
    'gpt-5-2-thinking': 'GPT 5.2 Thinking',
    'gpt-5-2-pro': 'GPT 5.2 Pro',
    // 5.1 系列显示名
    'gpt-5-1': 'GPT 5.1 Auto',
    'gpt-5-1-instant': 'GPT 5.1 Instant',
    'gpt-5-1-thinking': 'GPT 5.1 Thinking',
    'gpt-5-1-pro': 'GPT 5.1 Pro',
    'gpt-5-1-max': 'GPT 5.1 Max',
    'gpt-5-1-max-thinking': 'GPT 5.1 Max Thinking',

  }));

  // test 分组：主菜单里单独一组，置于最底部
  const TEST_GROUP_ORDER = [...TEST_ONLY_MODELS];

  function normalizeModelId(id) {
    if (!id) return '';
    return String(id).trim().toLowerCase().replace(/\s+/g, '-').replace(/\./g, '-');
  }

  function prettyName(id) {
    const norm = normalizeModelId(id);
    return CUSTOM_NAME_MAP.get(norm) || EXTRA_NAME_MAP.get(norm) || id || '';
  }

  function setAllSwitcherButtonsModel(modelId) {
    if (!modelId) return;
    const norm = normalizeModelId(modelId);
    const name = prettyName(norm);
    FM.info('update switcher state ->', name);
    // 不再直接改写按钮内部结构，避免干扰 React 的 DOM 管理（会导致 removeChild 报错）
    // 仅通过可见性无关的属性传递当前模型信息。
    document.querySelectorAll(`[data-testid="${TEST_ID_SWITCHER}"]`).forEach((btn) => {
      try { btn.setAttribute('aria-label', `Model selector, current model is ${norm}`); } catch {}
      try { btn.setAttribute('title', `ChatGPT ${name}`); } catch {}
      btn.dataset.currentModel = norm;
    });
    try { window.__fmCurrentModel = norm; } catch {}
    try { updateStandaloneToggleLabel(); } catch {}
  }

  function updateAllSwitcherButtonsFromURL() {
    const url = new URL(window.location.href);
    const currentModel = url.searchParams.get('model');
    if (!currentModel) return;
    setAllSwitcherButtonsModel(currentModel);
  }

  // ---------------- 设置面板（整合油猴菜单项） ----------------
  const SETTINGS_STYLE_ID = 'fm-settings-style';
  const SETTINGS_OVERLAY_ID = 'fm-settings-overlay';
  let settingsKeydownHandler = null;

  function ensureSettingsStyle() {
    if (document.getElementById(SETTINGS_STYLE_ID)) return;
    const style = document.createElement('style');
    style.id = SETTINGS_STYLE_ID;
    style.textContent = `
      #${SETTINGS_OVERLAY_ID}{
        position:fixed; inset:0; z-index:9999999998;
        background:rgba(0,0,0,0.45);
        display:flex; align-items:center; justify-content:center;
        padding:16px;
      }
      #${SETTINGS_OVERLAY_ID} *{ box-sizing:border-box; }
      #${SETTINGS_OVERLAY_ID} .fm-settings-panel{
        width:min(680px, 92vw); max-height:86vh;
        display:flex; flex-direction:column; overflow:hidden;
        border-radius:16px;
        background:var(--token-surface-primary, #fff);
        color:var(--token-text-primary, #111);
        border:1px solid var(--token-border, rgba(0,0,0,0.12));
        box-shadow:0 16px 48px rgba(0,0,0,0.18);
      }
      #${SETTINGS_OVERLAY_ID} .fm-settings-header{
        padding:12px 14px;
        display:flex; gap:12px; align-items:flex-start; justify-content:space-between;
        border-bottom:1px solid var(--token-border, rgba(0,0,0,0.12));
      }
      #${SETTINGS_OVERLAY_ID} .fm-settings-title{ font-size:14px; font-weight:750; line-height:1.2; }
      #${SETTINGS_OVERLAY_ID} .fm-settings-subtitle{ margin-top:2px; font-size:12px; color:var(--token-text-tertiary, rgba(0,0,0,0.65)); }
      #${SETTINGS_OVERLAY_ID} .fm-settings-close{
        border:1px solid var(--token-border, rgba(0,0,0,0.12));
        background:var(--token-surface-secondary, rgba(0,0,0,0.03));
        color:var(--token-text-primary, #111);
        border-radius:10px;
        padding:6px 10px;
        font-size:12px;
        cursor:pointer;
      }
      #${SETTINGS_OVERLAY_ID} .fm-settings-body{
        padding:12px 14px;
        display:flex; flex-direction:column; gap:12px;
        overflow:auto;
      }
      #${SETTINGS_OVERLAY_ID} .fm-settings-section{
        border:1px solid var(--token-border, rgba(0,0,0,0.12));
        background:var(--token-surface-secondary, rgba(0,0,0,0.03));
        border-radius:14px;
        padding:12px;
      }
      #${SETTINGS_OVERLAY_ID} .fm-sec-title{
        font-size:13px; font-weight:700;
        margin-bottom:8px;
      }
      #${SETTINGS_OVERLAY_ID} .fm-row{
        display:flex; gap:10px; align-items:center; justify-content:space-between;
        flex-wrap:wrap;
      }
      #${SETTINGS_OVERLAY_ID} .fm-row-left{
        display:flex; gap:10px; align-items:center; flex-wrap:wrap;
      }
      #${SETTINGS_OVERLAY_ID} .fm-hint{
        margin-top:8px;
        font-size:12px;
        color:var(--token-text-tertiary, rgba(0,0,0,0.65));
        line-height:1.35;
      }
      #${SETTINGS_OVERLAY_ID} select{
        border:1px solid var(--token-border, rgba(0,0,0,0.12));
        background:var(--token-surface-primary, #fff);
        color:var(--token-text-primary, #111);
        border-radius:10px;
        padding:7px 10px;
        font-size:12px;
        min-width:180px;
      }
      #${SETTINGS_OVERLAY_ID} .fm-btn{
        border:1px solid var(--token-border, rgba(0,0,0,0.12));
        background:var(--token-surface-primary, #fff);
        color:var(--token-text-primary, #111);
        border-radius:10px;
        padding:7px 10px;
        font-size:12px;
        cursor:pointer;
      }
      #${SETTINGS_OVERLAY_ID} .fm-btn.primary{
        background:#7c3aed;
        color:#fff;
        border-color:rgba(124,58,237,0.65);
      }
      #${SETTINGS_OVERLAY_ID} .fm-btn.danger{
        background:rgba(239,68,68,0.08);
        border-color:rgba(239,68,68,0.35);
        color:rgba(153,27,27,1);
      }
    `;
    (document.head || document.documentElement).appendChild(style);
  }

  function closeSettingsPanel() {
    const overlay = document.getElementById(SETTINGS_OVERLAY_ID);
    if (overlay) overlay.remove();
    if (settingsKeydownHandler) {
      try { window.removeEventListener('keydown', settingsKeydownHandler, true); } catch {}
      settingsKeydownHandler = null;
    }
  }

  function openSettingsPanel() {
    if (!document.body) { setTimeout(openSettingsPanel, 50); return; }
    if (document.getElementById(SETTINGS_OVERLAY_ID)) return;
    // 避免叠加两个 overlay
    try { closeModelOrderEditor(); } catch {}

    ensureSettingsStyle();

    const tierNow = getTier();
    let selectedTier = (tierNow || SUB_DEFAULT);

    const tierLabel = (t) => {
      const map = {
        free: 'Free',
        go: 'Go',
        k12: 'K12 Teacher',
        plus: 'Plus',
        team: 'Team',
        edu: 'Edu',
        enterprise: 'Enterprise',
        pro: 'Pro',
        test: 'Test（仅脚本内）',
      };
      return map[t] || t;
    };

    const overlay = document.createElement('div');
    overlay.id = SETTINGS_OVERLAY_ID;
    overlay.tabIndex = -1;

    const panel = document.createElement('div');
    panel.className = 'fm-settings-panel';

    const header = document.createElement('div');
    header.className = 'fm-settings-header';
    const headLeft = document.createElement('div');
    const title = document.createElement('div');
    title.className = 'fm-settings-title';
    title.textContent = '模型选择器设置';
    const subtitle = document.createElement('div');
    subtitle.className = 'fm-settings-subtitle';
    subtitle.textContent = `当前套餐：${tierNow ? tierLabel(tierNow) : '未设置'}（排序/隐藏按套餐分别保存）`;
    headLeft.appendChild(title);
    headLeft.appendChild(subtitle);
    const closeBtn = document.createElement('button');
    closeBtn.type = 'button';
    closeBtn.className = 'fm-settings-close';
    closeBtn.textContent = '关闭';
    closeBtn.addEventListener('click', () => closeSettingsPanel());
    header.appendChild(headLeft);
    header.appendChild(closeBtn);

    const body = document.createElement('div');
    body.className = 'fm-settings-body';

    const secTier = document.createElement('div');
    secTier.className = 'fm-settings-section';
    const secTierTitle = document.createElement('div');
    secTierTitle.className = 'fm-sec-title';
    secTierTitle.textContent = '订阅层级';
    const rowTier = document.createElement('div');
    rowTier.className = 'fm-row';
    const leftTier = document.createElement('div');
    leftTier.className = 'fm-row-left';
    const sel = document.createElement('select');
    for (const t of SUB_LEVELS) {
      const opt = document.createElement('option');
      opt.value = t;
      opt.textContent = tierLabel(t);
      sel.appendChild(opt);
    }
    sel.value = normalizeTierKey(selectedTier) || SUB_DEFAULT;
    sel.addEventListener('change', () => { selectedTier = sel.value; });
    leftTier.appendChild(sel);
    const btnSaveTier = document.createElement('button');
    btnSaveTier.type = 'button';
    btnSaveTier.className = 'fm-btn primary';
    btnSaveTier.textContent = '保存层级';
    btnSaveTier.addEventListener('click', () => {
      const next = normalizeTierKey(selectedTier) || SUB_DEFAULT;
      setTier(next);
      subtitle.textContent = `当前套餐：${tierLabel(getTier() || next)}（自定义顺序按套餐分别保存）`;
      try { alert(`已设置订阅层级：${next}\n\n提示：重新打开模型菜单即可生效。`); } catch {}
    });
    rowTier.appendChild(leftTier);
    rowTier.appendChild(btnSaveTier);
    const hintTier = document.createElement('div');
    hintTier.className = 'fm-hint';
    hintTier.textContent = '说明：这是脚本用来决定“显示/隐藏哪些模型”的本地设置，不会改变你的真实订阅权限。';
    secTier.appendChild(secTierTitle);
    secTier.appendChild(rowTier);
    secTier.appendChild(hintTier);

    const secOrder = document.createElement('div');
    secOrder.className = 'fm-settings-section';
    const secOrderTitle = document.createElement('div');
    secOrderTitle.className = 'fm-sec-title';
    secOrderTitle.textContent = '模型列表';
    const rowOrder = document.createElement('div');
    rowOrder.className = 'fm-row';
    const leftOrder = document.createElement('div');
    leftOrder.className = 'fm-row-left';
    const btnEdit = document.createElement('button');
    btnEdit.type = 'button';
    btnEdit.className = 'fm-btn primary';
    btnEdit.textContent = '编辑（排序/隐藏）';
    btnEdit.addEventListener('click', () => {
      const t = normalizeTierKey(selectedTier) || (getTier() || SUB_DEFAULT);
      closeSettingsPanel();
      openModelOrderEditor(t);
    });
    const btnReset = document.createElement('button');
    btnReset.type = 'button';
    btnReset.className = 'fm-btn danger';
    btnReset.textContent = '重置为默认';
    btnReset.addEventListener('click', () => {
      const t = normalizeTierKey(selectedTier) || (getTier() || SUB_DEFAULT);
      const ok = (() => { try { return confirm(`确定重置 ${t} 的“排序/隐藏”配置吗？`); } catch { return true; } })();
      if (!ok) return;
      clearCustomOrderForTier(t);
      clearHiddenModelsForTier(t);
      try { alert(`已重置：${t}\n\n提示：重新打开模型菜单即可生效。`); } catch {}
    });
    leftOrder.appendChild(btnEdit);
    leftOrder.appendChild(btnReset);
    const hintOrder = document.createElement('div');
    hintOrder.className = 'fm-hint';
    hintOrder.textContent = '编辑器支持拖拽排序，或选中后使用 ↑/↓；取消勾选即可隐藏；按套餐分别保存。';
    rowOrder.appendChild(leftOrder);
    secOrder.appendChild(secOrderTitle);
    secOrder.appendChild(rowOrder);
    secOrder.appendChild(hintOrder);

    body.appendChild(secTier);
    body.appendChild(secOrder);

    panel.appendChild(header);
    panel.appendChild(body);
    overlay.appendChild(panel);

    overlay.addEventListener('click', (e) => { if (e.target === overlay) closeSettingsPanel(); });
    settingsKeydownHandler = (e) => {
      if (!document.getElementById(SETTINGS_OVERLAY_ID)) return;
      if (e.key === 'Escape') { e.preventDefault(); closeSettingsPanel(); }
    };
    try { window.addEventListener('keydown', settingsKeydownHandler, true); } catch {}

    document.body.appendChild(overlay);
    try { overlay.focus({ preventScroll: true }); } catch {}
  }

  // ---------------- 自定义模型顺序：编辑器（拖拽 / ↑↓ 键） ----------------
  const ORDER_EDITOR_STYLE_ID = 'fm-order-style';
  const ORDER_EDITOR_OVERLAY_ID = 'fm-order-overlay';
  let orderEditorKeydownHandler = null;

  function ensureOrderEditorStyle() {
    if (document.getElementById(ORDER_EDITOR_STYLE_ID)) return;
    const style = document.createElement('style');
    style.id = ORDER_EDITOR_STYLE_ID;
    style.textContent = `
      #${ORDER_EDITOR_OVERLAY_ID}{
        position:fixed; inset:0; z-index:9999999999;
        background:rgba(0,0,0,0.45);
        display:flex; align-items:center; justify-content:center;
        padding:16px;
      }
      #${ORDER_EDITOR_OVERLAY_ID} *{ box-sizing:border-box; }
      #${ORDER_EDITOR_OVERLAY_ID} .fm-order-panel{
        width:min(720px, 92vw); max-height:86vh;
        display:flex; flex-direction:column; overflow:hidden;
        border-radius:16px;
        background:var(--token-surface-primary, #fff);
        color:var(--token-text-primary, #111);
        border:1px solid var(--token-border, rgba(0,0,0,0.12));
        box-shadow:0 16px 48px rgba(0,0,0,0.18);
      }
      #${ORDER_EDITOR_OVERLAY_ID} .fm-order-header{
        padding:12px 14px;
        display:flex; gap:12px; align-items:flex-start; justify-content:space-between;
        border-bottom:1px solid var(--token-border, rgba(0,0,0,0.12));
      }
      #${ORDER_EDITOR_OVERLAY_ID} .fm-order-title{ font-size:14px; font-weight:700; line-height:1.2; }
      #${ORDER_EDITOR_OVERLAY_ID} .fm-order-subtitle{ margin-top:2px; font-size:12px; color:var(--token-text-tertiary, rgba(0,0,0,0.65)); }
      #${ORDER_EDITOR_OVERLAY_ID} .fm-order-close{
        border:1px solid var(--token-border, rgba(0,0,0,0.12));
        background:var(--token-surface-secondary, rgba(0,0,0,0.03));
        color:var(--token-text-primary, #111);
        border-radius:10px;
        padding:6px 10px;
        font-size:12px;
        cursor:pointer;
      }
      #${ORDER_EDITOR_OVERLAY_ID} .fm-order-body{
        padding:12px 14px;
        display:flex; flex-direction:column; gap:10px;
        overflow:hidden;
      }
      #${ORDER_EDITOR_OVERLAY_ID} .fm-order-ops{
        display:flex; align-items:center; justify-content:space-between;
        gap:12px;
      }
      #${ORDER_EDITOR_OVERLAY_ID} .fm-order-tip{
        font-size:12px; color:var(--token-text-tertiary, rgba(0,0,0,0.65));
      }
      #${ORDER_EDITOR_OVERLAY_ID} .fm-order-only{
        display:flex; align-items:center; gap:8px;
        font-size:12px;
      }
      #${ORDER_EDITOR_OVERLAY_ID} .fm-order-list{
        flex:1; overflow:auto;
        padding:6px;
        border-radius:12px;
        background:var(--token-surface-secondary, rgba(0,0,0,0.03));
        border:1px solid var(--token-border, rgba(0,0,0,0.12));
      }
      #${ORDER_EDITOR_OVERLAY_ID} .fm-order-item{
        display:flex;
        gap:10px;
        align-items:flex-start;
        padding:10px 10px;
        border-radius:12px;
        background:var(--token-surface-primary, #fff);
        border:1px solid transparent;
        margin:6px 0;
        user-select:none;
        cursor:grab;
        outline:none;
      }
      #${ORDER_EDITOR_OVERLAY_ID} .fm-order-check{
        margin-top:2px;
        flex:0 0 auto;
      }
      #${ORDER_EDITOR_OVERLAY_ID} .fm-order-meta{
        flex:1 1 auto;
        min-width:0;
      }
      #${ORDER_EDITOR_OVERLAY_ID} .fm-order-item:hover{ border-color:var(--token-border, rgba(0,0,0,0.18)); }
      #${ORDER_EDITOR_OVERLAY_ID} .fm-order-item.is-selected{
        border-color:#7c3aed;
        box-shadow:0 0 0 3px rgba(124,58,237,0.15);
      }
      #${ORDER_EDITOR_OVERLAY_ID} .fm-order-item.is-dragging{ opacity:0.65; cursor:grabbing; }
      #${ORDER_EDITOR_OVERLAY_ID} .fm-order-item.is-hidden{
        opacity:0.55;
      }
      #${ORDER_EDITOR_OVERLAY_ID} .fm-order-main{
        display:flex; align-items:center; justify-content:space-between; gap:10px;
        font-size:13px; font-weight:650;
      }
      #${ORDER_EDITOR_OVERLAY_ID} .fm-order-sub{
        margin-top:2px;
        font-size:11px;
        color:var(--token-text-tertiary, rgba(0,0,0,0.65));
      }
      #${ORDER_EDITOR_OVERLAY_ID} .fm-order-badge{
        font-size:11px;
        padding:1px 8px;
        border-radius:999px;
        border:1px solid var(--token-border, rgba(0,0,0,0.12));
        background:rgba(0,0,0,0.04);
        color:rgba(0,0,0,0.65);
        flex:0 0 auto;
      }
      #${ORDER_EDITOR_OVERLAY_ID}.fm-only-allowed .fm-order-item.is-disabled{ display:none; }
      #${ORDER_EDITOR_OVERLAY_ID} .fm-order-footer{
        padding:12px 14px;
        display:flex; gap:10px; justify-content:flex-end; align-items:center;
        border-top:1px solid var(--token-border, rgba(0,0,0,0.12));
      }
      #${ORDER_EDITOR_OVERLAY_ID} .fm-order-btn{
        border:1px solid var(--token-border, rgba(0,0,0,0.12));
        background:var(--token-surface-secondary, rgba(0,0,0,0.03));
        color:var(--token-text-primary, #111);
        border-radius:10px;
        padding:8px 12px;
        font-size:12px;
        cursor:pointer;
      }
      #${ORDER_EDITOR_OVERLAY_ID} .fm-order-btn.primary{
        background:#7c3aed;
        color:#fff;
        border-color:rgba(124,58,237,0.65);
      }
      #${ORDER_EDITOR_OVERLAY_ID} .fm-order-btn.danger{
        background:rgba(239,68,68,0.08);
        border-color:rgba(239,68,68,0.35);
        color:rgba(153,27,27,1);
      }
    `;
    (document.head || document.documentElement).appendChild(style);
  }

  function buildOrderEditorModelIds(tier) {
    const ids = [];
    const seen = new Set();
    const push = (arr) => {
      for (const x of (Array.isArray(arr) ? arr : [])) {
        const id = normalizeModelId(x);
        if (!id || seen.has(id)) continue;
        seen.add(id);
        ids.push(id);
      }
    };
    push(getCustomOrderForTier(tier));
    push(getBaseDesiredOrderForTier(tier));
    try { push(CUSTOM_MODELS.map(m => m.id)); } catch {}
    push(TEST_ONLY_MODELS);
    // 确保已隐藏但不在清单中的“未知模型”也能被取消隐藏
    try { push(Array.from(getHiddenModelSetForTier(tier))); } catch {}
    return ids;
  }

  function closeModelOrderEditor() {
    const overlay = document.getElementById(ORDER_EDITOR_OVERLAY_ID);
    if (overlay) overlay.remove();
    if (orderEditorKeydownHandler) {
      try { window.removeEventListener('keydown', orderEditorKeydownHandler, true); } catch {}
      orderEditorKeydownHandler = null;
    }
  }

  function openModelOrderEditor(forceTier) {
    const forced = normalizeTierKey(forceTier);
    if (!forced) { try { ensureTierChosen(); } catch {} }
    const tier = forced || getTier() || SUB_DEFAULT;
    if (!document.body) { setTimeout(() => openModelOrderEditor(forceTier), 50); return; }
    if (document.getElementById(ORDER_EDITOR_OVERLAY_ID)) return;

    ensureOrderEditorStyle();
    const hiddenWorking = new Set(getHiddenModelSetForTier(tier));

    const overlay = document.createElement('div');
    overlay.id = ORDER_EDITOR_OVERLAY_ID;
    overlay.className = 'fm-only-allowed';
    overlay.tabIndex = -1;

    const panel = document.createElement('div');
    panel.className = 'fm-order-panel';

    const header = document.createElement('div');
    header.className = 'fm-order-header';
    const headLeft = document.createElement('div');
    const title = document.createElement('div');
    title.className = 'fm-order-title';
    title.textContent = '模型列表（排序/隐藏）';
    const subtitle = document.createElement('div');
    subtitle.className = 'fm-order-subtitle';
    subtitle.textContent = `当前套餐：${tier}（拖拽排序，或选中后用 ↑/↓；取消勾选=隐藏）`;
    headLeft.appendChild(title);
    headLeft.appendChild(subtitle);
    const closeBtn = document.createElement('button');
    closeBtn.type = 'button';
    closeBtn.className = 'fm-order-close';
    closeBtn.textContent = '关闭';
    closeBtn.addEventListener('click', () => closeModelOrderEditor());
    header.appendChild(headLeft);
    header.appendChild(closeBtn);

    const body = document.createElement('div');
    body.className = 'fm-order-body';

    const ops = document.createElement('div');
    ops.className = 'fm-order-ops';
    const tip = document.createElement('div');
    tip.className = 'fm-order-tip';
    tip.textContent = '提示：只影响本脚本的菜单显示与排序；不改变你的真实订阅权限。';
    const onlyWrap = document.createElement('label');
    onlyWrap.className = 'fm-order-only';
    const only = document.createElement('input');
    only.type = 'checkbox';
    only.checked = true;
    const onlyTxt = document.createElement('span');
    onlyTxt.textContent = '仅显示当前可用';
    only.addEventListener('change', () => {
      overlay.classList.toggle('fm-only-allowed', !!only.checked);
    });
    onlyWrap.appendChild(only);
    onlyWrap.appendChild(onlyTxt);
    ops.appendChild(tip);
    ops.appendChild(onlyWrap);

    const list = document.createElement('div');
    list.className = 'fm-order-list';
    list.setAttribute('role', 'listbox');

    let dragging = null;
    const selectItem = (el) => {
      list.querySelectorAll('.fm-order-item.is-selected').forEach(n => n.classList.remove('is-selected'));
      el.classList.add('is-selected');
      try { el.focus({ preventScroll: true }); } catch {}
    };
    const moveSelected = (delta) => {
      const sel = list.querySelector('.fm-order-item.is-selected');
      if (!sel) return;
      const sib = delta < 0 ? sel.previousElementSibling : sel.nextElementSibling;
      if (!sib || !sib.classList?.contains('fm-order-item')) return;
      if (delta < 0) list.insertBefore(sel, sib); else list.insertBefore(sel, sib.nextSibling);
      selectItem(sel);
      try { sel.scrollIntoView({ block: 'nearest' }); } catch {}
    };

    const render = () => {
      list.textContent = '';
      const ids = buildOrderEditorModelIds(tier);
      for (const id of ids) {
        const item = document.createElement('div');
        item.className = 'fm-order-item';
        item.tabIndex = 0;
        item.draggable = true;
        item.dataset.id = id;
        const allowed = isModelAllowedForTier(id, tier);
        if (!allowed) item.classList.add('is-disabled');
        if (hiddenWorking.has(id)) item.classList.add('is-hidden');

        const cb = document.createElement('input');
        cb.className = 'fm-order-check';
        cb.type = 'checkbox';
        cb.checked = !hiddenWorking.has(id);
        cb.addEventListener('change', () => {
          if (cb.checked) hiddenWorking.delete(id);
          else hiddenWorking.add(id);
          item.classList.toggle('is-hidden', hiddenWorking.has(id));
        });

        const meta = document.createElement('div');
        meta.className = 'fm-order-meta';
        const main = document.createElement('div');
        main.className = 'fm-order-main';
        const name = document.createElement('span');
        name.textContent = `${prettyName(id)}(${id})`;
        main.appendChild(name);
        if (!allowed) {
          const badge = document.createElement('span');
          badge.className = 'fm-order-badge';
          badge.textContent = '不可用';
          main.appendChild(badge);
        }
        meta.appendChild(main);
        item.appendChild(cb);
        item.appendChild(meta);

        item.addEventListener('click', () => { selectItem(item); });
        item.addEventListener('focus', () => selectItem(item));
        list.appendChild(item);
      }
      const first = list.querySelector('.fm-order-item');
      if (first) selectItem(first);
    };

    list.addEventListener('dragstart', (e) => {
      const t = e.target;
      if (!(t instanceof Element)) return;
      const item = t.closest('.fm-order-item');
      if (!item) return;
      dragging = item;
      selectItem(item);
      item.classList.add('is-dragging');
      try { e.dataTransfer.effectAllowed = 'move'; e.dataTransfer.setData('text/plain', item.dataset.id || ''); } catch {}
    });
    list.addEventListener('dragover', (e) => {
      if (!dragging) return;
      e.preventDefault();
      const t = e.target;
      if (!(t instanceof Element)) return;
      const over = t.closest('.fm-order-item');
      if (!over || over === dragging) return;
      const rect = over.getBoundingClientRect();
      const after = e.clientY > rect.top + rect.height / 2;
      list.insertBefore(dragging, after ? over.nextSibling : over);
    });
    list.addEventListener('drop', (e) => { if (dragging) e.preventDefault(); });
    list.addEventListener('dragend', () => {
      if (dragging) dragging.classList.remove('is-dragging');
      dragging = null;
    });

    const footer = document.createElement('div');
    footer.className = 'fm-order-footer';
    const showAllBtn = document.createElement('button');
    showAllBtn.type = 'button';
    showAllBtn.className = 'fm-order-btn';
    showAllBtn.textContent = '全部显示';
    showAllBtn.addEventListener('click', () => {
      hiddenWorking.clear();
      list.querySelectorAll('.fm-order-item').forEach((el) => {
        el.classList.remove('is-hidden');
        const cb = el.querySelector('input.fm-order-check');
        if (cb) cb.checked = true;
      });
    });
    const resetBtn = document.createElement('button');
    resetBtn.type = 'button';
    resetBtn.className = 'fm-order-btn danger';
    resetBtn.textContent = '重置为默认';
    resetBtn.addEventListener('click', () => {
      clearCustomOrderForTier(tier);
      clearHiddenModelsForTier(tier);
      hiddenWorking.clear();
      render();
      try { alert('已重置。重新打开模型菜单即可生效。'); } catch {}
    });
    const cancelBtn = document.createElement('button');
    cancelBtn.type = 'button';
    cancelBtn.className = 'fm-order-btn';
    cancelBtn.textContent = '取消';
    cancelBtn.addEventListener('click', () => closeModelOrderEditor());
    const saveBtn = document.createElement('button');
    saveBtn.type = 'button';
    saveBtn.className = 'fm-order-btn primary';
    saveBtn.textContent = '保存';
    saveBtn.addEventListener('click', () => {
      const ids = Array.from(list.querySelectorAll('.fm-order-item')).map(el => normalizeModelId(el.dataset.id || '')).filter(Boolean);
      setCustomOrderForTier(tier, ids);
      setHiddenModelsForTier(tier, Array.from(hiddenWorking));
      closeModelOrderEditor();
      try { alert('已保存。重新打开模型菜单即可生效。'); } catch {}
    });

    footer.appendChild(showAllBtn);
    footer.appendChild(resetBtn);
    footer.appendChild(cancelBtn);
    footer.appendChild(saveBtn);

    body.appendChild(ops);
    body.appendChild(list);

    panel.appendChild(header);
    panel.appendChild(body);
    panel.appendChild(footer);
    overlay.appendChild(panel);
    overlay.addEventListener('click', (e) => { if (e.target === overlay) closeModelOrderEditor(); });

    orderEditorKeydownHandler = (e) => {
      if (!document.getElementById(ORDER_EDITOR_OVERLAY_ID)) return;
      const target = e.target;
      const tag = target && target.tagName ? String(target.tagName).toLowerCase() : '';
      if (tag === 'input' || tag === 'textarea' || tag === 'select' || target?.isContentEditable) return;
      if (e.key === 'Escape') { e.preventDefault(); closeModelOrderEditor(); return; }
      if (e.key === 'ArrowUp') { e.preventDefault(); moveSelected(-1); return; }
      if (e.key === 'ArrowDown') { e.preventDefault(); moveSelected(1); return; }
    };
    try { window.addEventListener('keydown', orderEditorKeydownHandler, true); } catch {}

    document.body.appendChild(overlay);
    render();
    try { overlay.focus({ preventScroll: true }); } catch {}
  }

  function findAssociatedMenu(triggerBtn) {
    const id = triggerBtn.getAttribute('id');
    if (!id) return null;
    return document.querySelector(`[role="menu"][aria-labelledby="${CSS.escape(id)}"]`);
  }

  // 关闭（收起）与某按钮关联的 Main 模型选择器。
  function closeMenu(menuEl) {
    try {
      const menu = menuEl && (menuEl.closest?.('[role="menu"], [role="listbox"], [data-radix-menu-content]') || menuEl);
      if (!menu || !(menu instanceof HTMLElement)) return false;
      const labeledBy = menu.getAttribute('aria-labelledby');
      if (labeledBy) {
        const btn = document.getElementById(labeledBy);
        if (btn) {
          try { btn.dispatchEvent(new PointerEvent('pointerdown', { bubbles: true })); } catch {}
          try { btn.click(); } catch {}
          return true;
        }
      }
      // 回退：发送 Escape 事件尝试关闭 Radix 下拉
      const target = document.activeElement || menu;
      try { target.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', code: 'Escape', keyCode: 27, which: 27, bubbles: true })); } catch {}
      try { target.dispatchEvent(new KeyboardEvent('keyup', { key: 'Escape', code: 'Escape', keyCode: 27, which: 27, bubbles: true })); } catch {}
      return true;
    } catch {
      return false;
    }
  }

  // 仅识别“Main 模型选择器”（排除包含 Auto/Instant/Thinking/Pro 的“使用其他模型重试的模型选择器”）
  // Main 菜单识别：有 Main 菜单签名 + 不包含重试关键字
  function isOfficialModelMenu(menuEl) {
    if (!menuEl || !(menuEl instanceof HTMLElement)) return false;
    const role = menuEl.getAttribute('role');
    if (role !== 'menu' && role !== 'listbox') return false;
    const items = Array.from(menuEl.querySelectorAll('[role="menuitem"], [data-radix-collection-item]'));
    const labels = items.map((el) => {
      const t = el.querySelector?.('.truncate');
      const raw = (t?.textContent ?? el.textContent ?? '').trim();
      return raw.split('\n')[0].trim();
    });
    const hasVariantMarker = labels.some((l) => /^(Auto|Instant|Thinking(?: mini)?|Pro|Ultra(?:\s*Think(?:ing)?)?)$/i.test(l));
    if (hasVariantMarker) return false;
    const hasOfficialSignature = !!(menuEl.querySelector('[data-testid^="model-switcher-"]') || menuEl.querySelector('[data-cgpt-turn]'));
    if (!hasOfficialSignature) return false;
    return true;
  }

  // ---------------- 黏性重排 ----------------
  // 黏性重排：把“我们关心的项”按照订阅层级对应的顺序，
  // 仅在不一致时最小化 DOM 变动地整体移动，避免 hover 抖动/菜单意外关闭。
  const STICKY_REORDER = new WeakMap();

  function findItemNode(menu, id) {
    let node = menu.querySelector(`[data-radix-collection-item][data-testid="model-switcher-${CSS.escape(id)}"]`)
            || menu.querySelector(`[data-testid="model-switcher-${CSS.escape(id)}"]`)
            || menu.querySelector(`[data-custom-model="${CSS.escape(id)}"]`);
    if (!node && ALT_IDS[id]) {
      for (const alt of ALT_IDS[id]) {
        node = menu.querySelector(`[data-testid="model-switcher-${CSS.escape(alt)}"]`)
            || menu.querySelector(`[data-custom-model="${CSS.escape(alt)}"]`);
        if (node) break;
      }
    }
    return node;
  }

  // 对 Main 模型选择器进行“黏性重排”（与 addCustomModels 配合）。
  function applyDesiredOrder(menu) {
    // 1) 收集期望顺序中、当前实际存在于该菜单且“当前层级允许”的“顶层项”节点
    const desiredNodes = [];
    const seen = new Set();
    const desiredOrder = getDesiredOrder();
    for (const id of desiredOrder) {
      if (!isModelAllowed(id)) continue;
      let n = findItemNode(menu, id);
      if (!n) continue;
      // 升到以 menu 为直接父级的顶层容器，避免移动子层导致 hover 抖动
      while (n && n.parentElement && n.parentElement !== menu) n = n.parentElement;
      if (!n || seen.has(n)) continue;
      seen.add(n);
      desiredNodes.push(n);
    }
    if (desiredNodes.length === 0) return;

    // 2) 取当前顺序：按 menu.children 顺序过滤出我们关心的节点
    const current = Array.from(menu.children).filter(ch => seen.has(ch));

    // 3) 若顺序已匹配，则不做任何 DOM 变动（避免 pointerleave/blur 导致菜单关闭）
    const sameOrder = current.length === desiredNodes.length && current.every((n, i) => n === desiredNodes[i]);
    if (sameOrder) return;

    // 4) 仅在不一致时才整体移动，以最小化变更次数
    const frag = document.createDocumentFragment();
    desiredNodes.forEach(n => frag.appendChild(n));
    menu.appendChild(frag);
  }

  // UI 微调：压缩 GPT‑5 系列二行描述、统一标题、隐藏“Legacy models”入口和相关分隔线。
  function normalizeMenuUI(menu) {
    try {
      // 压缩 GPT‑5/5.1/5.2 系列项：去除第二行描述
      const g5 = menu.querySelectorAll('[data-testid^="model-switcher-gpt-5"], [data-radix-collection-item][data-testid^="model-switcher-gpt-5"], [data-testid^="model-switcher-gpt-5-1"], [data-radix-collection-item][data-testid^="model-switcher-gpt-5-1"], [data-testid^="model-switcher-gpt-5-2"], [data-radix-collection-item][data-testid^="model-switcher-gpt-5-2"]');
      g5.forEach((el) => {
        const container = el.querySelector('.min-w-0');
        if (!container) return;
        const children = Array.from(container.children);
        children.forEach((node, idx) => { if (idx >= 1 && node.tagName === 'DIV') node.remove(); });
      });
      // 标题规范化
      const rename = (key, text) => {
        const n = menu.querySelector(`[data-radix-collection-item][data-testid="model-switcher-${key}"] .min-w-0 span`)
              || menu.querySelector(`[data-testid="model-switcher-${key}"] .min-w-0 span`);
        if (n) n.textContent = text;
      };
      // 新增 5.2 系列标题规范
      rename('gpt-5-2', 'GPT 5.2 Auto');
      rename('gpt-5-2-instant', 'GPT 5.2 Instant');
      rename('gpt-5-2-thinking', 'GPT 5.2 Thinking');
      rename('gpt-5-2-pro', 'GPT 5.2 Pro');
      rename('gpt-5', 'GPT 5 Auto');
      rename('gpt-5-instant', 'GPT 5 Instant');
      rename('gpt-5-t-mini', 'GPT 5 Thinking Mini');
      rename('gpt-5-mini', 'GPT 5 mini');
      rename('gpt-5-thinking', 'GPT 5 Thinking');
      rename('gpt-5-pro', 'GPT 5 Pro');
      // 新增 5.1 系列标题规范
      rename('gpt-5-1', 'GPT 5.1 Auto');
      rename('gpt-5-1-instant', 'GPT 5.1 Instant');
      rename('gpt-5-1-thinking', 'GPT 5.1 Thinking');
      rename('gpt-5-1-pro', 'GPT 5.1 Pro');
      rename('gpt-5-1-max', 'GPT 5.1 Max');
      rename('gpt-5-1-max-thinking', 'GPT 5.1 Max Thinking');

      // 隐藏 Legacy models 子菜单入口
      const toHide = new Set();
      const exact = menu.querySelector('[data-testid="Legacy models-submenu"]');
      if (exact) toHide.add(exact);
      menu.querySelectorAll('[role="menuitem"][data-has-submenu]').forEach((el) => {
        const txt = (el.textContent || '').toLowerCase();
        const tid = (el.getAttribute('data-testid') || '').toLowerCase();
        if (txt.includes('legacy models') || tid.includes('legacy models')) toHide.add(el);
      });
      toHide.forEach((el) => { el.style.display = 'none'; el.setAttribute('data-ext-hidden','1'); });

      // 隐藏“GPT-5”分组标题与紧随的分隔线
      menu.querySelectorAll('div.__menu-label.mb-0').forEach((el) => {
        const t = (el.textContent || '').trim();
        if (t === 'GPT-5') {
          el.style.display = 'none';
          el.setAttribute('data-ext-hidden','1');
          const sep = el.nextElementSibling;
          if (sep && sep.getAttribute('role') === 'separator') {
            sep.style.display = 'none';
            sep.setAttribute('data-ext-hidden','1');
          }
        }
      });
      // 保险：具有这些类名的分隔线也隐藏
      menu.querySelectorAll('[role="separator"].bg-token-border-default.h-px.mx-4.my-1').forEach((el) => {
        el.style.display = 'none';
        el.setAttribute('data-ext-hidden','1');
      });
    } catch {}
  }

  // 按订阅层级隐藏/显示菜单项（官方项与自定义项均处理）
  function syncMenuByTier(menu) {
    try {
      const tier = getTier() || SUB_DEFAULT;
      const hidden = getHiddenModelSetForTier(tier);
      // 遍历当前菜单中所有“模型项”（官方或自定义）
      const allItems = Array.from(menu.querySelectorAll('[data-radix-collection-item][data-testid^="model-switcher-"], [data-testid^="model-switcher-"]'));
      for (const el of allItems) {
        const testid = el.getAttribute('data-testid') || '';
        const m = /^model-switcher-(.+)$/.exec(testid);
        const id = m ? normalizeModelId(m[1]) : '';
        if (!id) continue;
        // 升为顶层节点
        let n = el;
        while (n && n.parentElement && n.parentElement !== menu) n = n.parentElement;
        const allowed = isModelAllowedForTier(id, tier);
        const visible = allowed && !hidden.has(id);
        if (n && n instanceof HTMLElement) {
          if (visible) {
            if (n.dataset.extTierHidden === '1') {
              n.style.display = '';
              delete n.dataset.extTierHidden;
            }
          } else {
            n.style.display = 'none';
            n.dataset.extTierHidden = '1';
          }
        }
      }
    } catch {}
  }

  function ensureStickyReorder(menu) {
    if (!menu || STICKY_REORDER.has(menu)) return;
    let scheduled = false;
    const schedule = () => {
      if (scheduled) return;
      scheduled = true;
      requestAnimationFrame(() => {
        scheduled = false;
        try { normalizeMenuUI(menu); } catch {}
        try { syncMenuByTier(menu); } catch {}
        try { applyDesiredOrder(menu); } catch {}
      });
    };
    const mo = new MutationObserver((muts) => {
      for (const m of muts) {
        if (m.type === 'childList') { schedule(); break; }
      }
    });
    mo.observe(menu, { childList: true });
    STICKY_REORDER.set(menu, mo);
    schedule(); // 首次也排一次
  }

  // ---------------- 自定义项：原生风格 + 丝滑选择 ----------------
  // 丝滑选择：
  // 1) 立即更新 URL 中的 ?model= 和顶部按钮文案（无闪烁），
  // 2) 再尝试点击同 id 的官方项（若可用），不做拦截改写（回归原始行为）。
  function selectModelQuick(id) {
    // 1) 立即更新 URL 和按钮文案（丝滑）
    if (!isModelAllowed(id)) {
      try { alert('当前订阅层级不可使用该模型'); } catch {}
      return;
    }
    try {
      const url = new URL(window.location.href);
      // url.searchParams.set('model', id); // 2.1: 暂停向 URL 写入 ?model 参数
      history.pushState({}, '', url.toString());
      try { window.dispatchEvent(new Event('pushstate')); } catch {}
      try { window.dispatchEvent(new Event('locationchange')); } catch {}
      try { window.dispatchEvent(new PopStateEvent('popstate')); } catch {}
      setAllSwitcherButtonsModel(id);
    } catch {}

    // 2) 联动点官方同 id 项（若成功可提前生效）
    const sel = `[data-radix-collection-item][data-testid="model-switcher-${CSS.escape(id)}"]:not([data-ext-custom])`;
    const tryClick = () => {
      const el = document.querySelector(sel);
      if (!el) return false;
      try { FM.info('click official menu item for', id); } catch {}
      el.dispatchEvent(new PointerEvent('pointerdown', { bubbles: true }));
      el.click();
      return true;
    };
    requestAnimationFrame(() => { if (!tryClick()) setTimeout(tryClick, 120); });
  }

  function createNativeLikeCustomItem(id, label) {
    const item = document.createElement('div');
    item.setAttribute('role','menuitem');
    item.setAttribute('tabindex','0');
    item.className = 'group __menu-item';
    item.setAttribute('data-radix-collection-item','');
    item.setAttribute('data-orientation','vertical');
    item.dataset.testid = `model-switcher-${id}`; // data-testid（保持一致，以便排序匹配）
    item.setAttribute('data-custom-model', id);
    item.setAttribute('data-ext-custom','1');    // 防止被“点官方项”逻辑误点

    item.innerHTML = `
      <div class="min-w-0">
        <span class="flex items-center gap-1">${label || id}</span>
      </div>
      <div class="trailing"><span class="icon"></span></div>
    `;

    const swallow = (e) => { e.preventDefault(); e.stopPropagation(); };
    item.addEventListener('pointerdown', swallow, { capture: true });
    item.addEventListener('mousedown', swallow, { capture: true });
    item.addEventListener('click', (e) => {
      e.preventDefault(); e.stopPropagation();
      const menuRoot = item.closest('[role="menu"], [role="listbox"], [data-radix-menu-content]');
      try { FM.info('main choose -> sticky', id); } catch {}
      try { setForceSticky(id); } catch {}
      selectModelQuick(id);
      // 稍等一拍，确保原生项点击处理完成后再收起菜单
      if (!NO_CLOSE_ON_CHOOSE_IDS.has(normalizeModelId(id))) {
        setTimeout(() => { try { closeMenu(menuRoot); } catch {} }, 30);
      }
    }, { capture: true });
    return item;
  }

  // 在“Main 模型选择器”中插入自定义项（仅在该菜单没有同名原生项时）：
  // - 插在“最后一个 GPT‑5 官方项”之后（找不到则末尾）
  // - 插入后调用 normalizeMenuUI / applyDesiredOrder 统一外观与顺序
  function addCustomModels(menuEl) {
    if (!menuEl || !(menuEl instanceof HTMLElement)) return;
    if (menuEl.dataset.customized === 'true') return;

    // 在最后一个 GPT‑5 原生项后插入（找不到就追加到末尾）
    const anchors = menuEl.querySelectorAll('[data-radix-collection-item][data-testid^="model-switcher-gpt-5"]');
    const lastG5 = anchors[anchors.length - 1];
    const tier = getTier() || SUB_DEFAULT;
    const hidden = getHiddenModelSetForTier(tier);

    for (const { id, label } of CUSTOM_MODELS) {
      if (hidden.has(normalizeModelId(id))) continue;
      // 过滤：订阅层级不允许的模型不插入
      if (!isModelAllowed(id)) continue;
      // 跳过：若菜单中已有原生同 id 项
      const existsOfficial = menuEl.querySelector(`[data-testid="model-switcher-${CSS.escape(id)}"]:not([data-ext-custom])`);
      if (existsOfficial) continue;
      // 跳过：已插过
      if (menuEl.querySelector(`[data-custom-model="${CSS.escape(id)}"]`)) continue;
      const item = createNativeLikeCustomItem(id, label || id);
      if (lastG5 && lastG5.parentElement === menuEl) lastG5.after(item); else menuEl.appendChild(item);
    }

    menuEl.dataset.customized = 'true';
    try { normalizeMenuUI(menuEl); } catch {}
    try { syncMenuByTier(menuEl); } catch {}
    try { applyDesiredOrder(menuEl); } catch {}

    // 若用户点选了官方项（或键盘触发 click），则自动收起菜单
    if (!menuEl.dataset.fmCloseOnChoose) {
      menuEl.addEventListener('click', (ev) => {
        const t = ev.target;
        if (!t || !(t instanceof Element)) return;
        const item = t.closest('[data-radix-collection-item][data-testid^="model-switcher-"]:not([data-ext-custom])')
                 || t.closest('[data-testid^="model-switcher-"]:not([data-ext-custom])');
        if (!item) return;
        const testid = item.getAttribute('data-testid') || '';
        const m = /^model-switcher-(.+)$/.exec(testid);
        const chosenId = m ? normalizeModelId(m[1]) : '';
        if (chosenId && !isModelAllowed(chosenId)) { ev.preventDefault(); ev.stopPropagation(); return; }
        // 官方主菜单项：选择即设为常驻拦截
        if (chosenId) { try { FM.info('main official choose -> sticky', chosenId); } catch {} try { setForceSticky(chosenId); } catch {} }
        if (chosenId && NO_CLOSE_ON_CHOOSE_IDS.has(chosenId)) return;
        setTimeout(() => { try { closeMenu(menuEl); } catch {} }, 30);
      }, { capture: true });
      menuEl.dataset.fmCloseOnChoose = '1';
    }
  }

  // ---------------- 使用其他模型重试的模型选择器：快捷项 + 强制窗口 + fetch 改写 ----------------
  let lastVariantMenuRoot = null;
  const isMenuRoot = (n) => n && n.nodeType === 1 && (
    n.matches?.('[data-radix-menu-content]') ||
    n.matches?.('[data-radix-dropdown-menu-content]') ||
    (n.getAttribute?.('role') === 'menu')
  );
  const VARIANT_MARKERS = [/^Auto$/i, /^Instant$/i, /^Thinking(?: mini)?$/i, /^Pro$/i, /^Ultra(?:\s*Think(?:ing)?)?$/i];
  function getItemLabel(el) {
    const t = el.querySelector?.('.truncate');
    const raw = (t?.textContent ?? el.textContent ?? '').trim();
    return raw.split('\n')[0].trim();
  }
  // “重试模型选择器”识别：包含关键字（Auto/Instant/Thinking/Pro/Ultra）+ 不含 Main 菜单签名。
  function isVariantMenu(root) {
    if (!isMenuRoot(root)) return false;
    // 排除 Main 模型选择器特征
    if (root.querySelector('[data-testid^="model-switcher-"]') || root.querySelector('[data-cgpt-turn]')) return false;
    const items = [...root.querySelectorAll('[role^="menuitem"]')];
    const hasVariant = items.some(el => VARIANT_MARKERS.some(re => re.test(getItemLabel(el))));
    return hasVariant;
  }
  // 回退“重试/Regenerate”按钮查找：当未能触发原生项时使用。
  function findRetryBtn() {
    let btn = document.querySelector('[data-testid*="regenerate"], [data-testid*="retry"]');
    if (btn) return btn;
    btn = [...document.querySelectorAll('button[aria-label]')].find(b => /regenerate|retry|重试|重新生成/i.test(b.getAttribute('aria-label') || ''));
    if (btn) return btn;
    btn = [...document.querySelectorAll('button')].find(b => /regenerate|retry|重试|重新生成/i.test((b.textContent || '').trim()));
    return btn || null;
  }
  // 在“重试模型选择器”中寻找一个“锚点项”（插入快捷项时作为参照）。
  function findNativeAnchor(root) {
    if (!root) return null;
    const items = [...root.querySelectorAll('[role^="menuitem"]')];
    const NATIVE_ANCHOR_TEXTS = [/^o4-mini$/i, /^gpt-4o$/i, /^gpt-4\.?1$/i];
    for (const re of NATIVE_ANCHOR_TEXTS) {
      const hit = items.find(el => re.test(getItemLabel(el)));
      if (hit) return hit;
    }
    return items[0] || null;
  }
  // 优先触发“重试模型选择器”里的原生项；若不存在则触发“重试/Regenerate”按钮。
  function clickNativeOrRetry() {
    // 优先直接触发“重试/Regenerate”，确保立即产生一次对话请求以消费一次性覆盖/抑制
    const retry = findRetryBtn();
    if (retry) {
      try { FM.info('variant click -> retry button'); } catch {}
      retry.dispatchEvent(new PointerEvent('pointerdown', { bubbles: true }));
      retry.click();
      return true;
    }
    // 回退：点击一个稳定存在的原生锚点项（如 o4 mini / gpt-4o / gpt-4.1）
    const nativeItem = findNativeAnchor(lastVariantMenuRoot);
    if (nativeItem) {
      try { FM.info('variant click -> native anchor'); } catch {}
      nativeItem.dispatchEvent(new PointerEvent('pointerdown', { bubbles: true }));
      nativeItem.click();
      return true;
    }
    console.warn('[fm] 未找到原生菜单项或“重试”按钮；请手动触发一次重试/选择模型。');
    return false;
  }
  // 拦截模型策略（更新后）：
  // - 兼容旧的“时间窗”方式（setForce），但默认采用“常驻拦截”。
  // - UI：左侧显示当前拦截状态，可取消。
  let forceModel = null; // 旧：时间窗（保留兼容，不默认使用）
  let forceUntil = 0;
  const inWindow = () => forceModel && Date.now() < forceUntil;
  function setForce(model, ms = 2000) { // 兼容旧逻辑（仍保留）
    forceModel = String(model || '').trim();
    forceUntil = Date.now() + ms;
    try { console.info(`[fm] force ${forceModel} for ${ms}ms`); } catch {}
    setTimeout(() => { if (Date.now() >= forceUntil) { forceModel = null; forceUntil = 0; } }, ms + 100);
  }

  // 常驻拦截（每个标签页独立生效）
  let forceModelSticky = null;      // 常驻拦截：始终改写为该模型（每个标签页独立）
  let forceModelOverrideOnce = null; // 临时重试覆盖：只对下一次请求生效，随后恢复常驻
  let suppressStickyUntil = 0;       // 临时抑制窗口：在窗口期内，下一次“会话请求”不应用常驻
  let stickyHardBlockUntil = 0;      // 硬阻断窗口：override armed 时，短时彻底禁用 sticky
  let interceptBadge = null;        // UI 元素
  let repositionTimer = null;       // 节流定位计时
  function setForceSticky(modelId) {
    forceModelSticky = String(modelId || '').trim();
    if (!forceModelSticky) return;
    try { FM.info('sticky on ->', forceModelSticky); } catch {}
    updateInterceptBadge('on');
    try { updateStandaloneToggleLabel(); } catch {}
  }
  function clearForceSticky() {
    forceModelSticky = null;
    try { FM.info('sticky off'); } catch {}
    updateInterceptBadge('off');
    try { updateStandaloneToggleLabel(); } catch {}
  }
  function setOverrideOnce(modelId) {
    forceModelOverrideOnce = String(modelId || '').trim();
    try { FM.info('override once ->', forceModelOverrideOnce); } catch {}
    // 不改徽标文字，保持显示常驻模型
    // 开一个硬阻断窗口：在 override 消耗前，sticky 完全不介入会话请求
    try { stickyHardBlockUntil = Date.now() + 15000; } catch {}
  }
  function clearOverrideOnce() {
    forceModelOverrideOnce = null;
    try { FM.info('override cleared'); } catch {}
  }
  function suppressStickyNext(label = '') {
    // 开启一个短窗口（10s），仅对“下一个会话请求”生效，并且只在真正的会话端点上消耗
    try { FM.info('suppress sticky window start by native retry ->', label); } catch {}
    suppressStickyUntil = Date.now() + 10000;
  }
  // 无单次消耗逻辑

  function ensureInterceptBadge() {
    // 若已有，直接复用；顺便清理重复的旧节点
    const exist = document.getElementById('fm-intercept-badge');
    if (exist) {
      interceptBadge = exist;
      // 清理重复
      const dups = document.querySelectorAll('#fm-intercept-badge');
      if (dups.length > 1) {
        dups.forEach((n, i) => { if (i > 0 && n !== exist) n.remove(); });
      }
      try { FM.log('badge reuse'); } catch {}
      return exist;
    }

    const badge = document.createElement('div');
    badge.id = 'fm-intercept-badge';
    badge.style.position = 'fixed';
    badge.style.left = '10px'; // 初始占位，稍后会靠近模型选择器
    badge.style.top = '10px';
    badge.style.zIndex = '9999999999';
    badge.style.pointerEvents = 'auto';
    badge.style.padding = '3px 8px';
    badge.style.borderRadius = '999px';
    badge.style.fontSize = '12px';
    badge.style.lineHeight = '1.2';
    badge.style.background = 'var(--token-surface-brand, #10a37f)';
    badge.style.color = '#fff';
    badge.style.boxShadow = '0 2px 8px rgba(0,0,0,0.2)';
    badge.style.userSelect = 'none';
    badge.style.cursor = 'default';
    badge.style.display = 'none';
    badge.style.maxWidth = '220px';
    badge.style.whiteSpace = 'nowrap';
    badge.style.overflow = 'hidden';
    badge.style.textOverflow = 'ellipsis';

    const text = document.createElement('span');
    text.id = 'fm-intercept-text';
    badge.appendChild(text);

    const spacer = document.createElement('span');
    spacer.textContent = ' ';
    badge.appendChild(spacer);

    const cancel = document.createElement('button');
    cancel.type = 'button';
    cancel.textContent = '×';
    cancel.style.marginLeft = '6px';
    cancel.style.fontSize = '12px';
    cancel.style.padding = '2px 6px';
    cancel.style.border = 'none';
    cancel.style.borderRadius = '999px';
    cancel.style.background = 'transparent';
    cancel.style.color = 'inherit';
    cancel.addEventListener('click', (e) => {
      e.stopPropagation(); e.preventDefault();
      try { FM.info('badge cancel clicked'); } catch {}
      clearForceSticky();
    });
    badge.appendChild(cancel);

    const container = document.body || document.documentElement;
    container.appendChild(badge);
    interceptBadge = badge;
    try { FM.log('badge create'); } catch {}
    return badge;
  }
  function getVisibleSwitcherBtn() {
    const list = document.querySelectorAll(`[data-testid="${TEST_ID_SWITCHER}"]`);
    for (const el of list) {
      const rect = el.getBoundingClientRect();
      const visible = rect.width > 0 && rect.height > 0 && rect.bottom > 0 && rect.right > 0 && rect.left < (window.innerWidth || 0) && rect.top < (window.innerHeight || 0);
      if (visible) return el;
    }
    // fallback: use standalone toggle if visible
    const fallback = document.getElementById('fm-standalone-toggle');
    if (fallback) {
      try {
        const r = fallback.getBoundingClientRect();
        const ok = r.width > 0 && r.height > 0 && r.bottom > 0 && r.right > 0 && r.left < (window.innerWidth || 0) && r.top < (window.innerHeight || 0);
        if (ok) return fallback;
      } catch {}
    }
    return null;
  }

  // ---------------- 独立模型选择器（在无官方切换按钮的页面提供入口） ----------------
  function hasNativeSwitcherVisible() {
    const list = document.querySelectorAll(`[data-testid="${TEST_ID_SWITCHER}"]`);
    for (const el of list) {
      const rect = el.getBoundingClientRect();
      const visible = rect.width > 0 && rect.height > 0 && rect.bottom > 0 && rect.right > 0 && rect.left < (window.innerWidth || 0) && rect.top < (window.innerHeight || 0);
      if (visible) return true;
    }
    return false;
  }

  function buildStandaloneMenuItems(menu) {
    if (!menu) return;
    menu.textContent = '';
    const desired = getDesiredOrder();
    const used = new Set();
    for (const id of desired) {
      if (used.has(id)) continue;
      used.add(id);
      if (!isModelAllowed(id)) continue;
      const item = document.createElement('div');
      item.className = '__fm-standalone-item';
      item.setAttribute('data-model-id', id);
      item.textContent = prettyName(id);
      item.addEventListener('click', (e) => {
        e.preventDefault(); e.stopPropagation();
        try { setForceSticky(id); } catch {}
        try { selectModelQuick(id); } catch {}
        try { hideStandaloneMenu(); } catch {}
      });
      menu.appendChild(item);
    }
  }

  function getCurrentModelIdForDisplay() {
    // 1) 优先显示常驻模型
    if (forceModelSticky) return normalizeModelId(forceModelSticky);
    // 2) 取可见原生按钮标记的当前模型
    const list = document.querySelectorAll(`[data-testid="${TEST_ID_SWITCHER}"]`);
    for (const el of list) {
      try {
        const rect = el.getBoundingClientRect();
        const visible = rect.width > 0 && rect.height > 0 && rect.bottom > 0 && rect.right > 0 && rect.left < (window.innerWidth || 0) && rect.top < (window.innerHeight || 0);
        const cur = (el.dataset && el.dataset.currentModel) ? normalizeModelId(el.dataset.currentModel) : '';
        if (visible && cur) return cur;
      } catch {}
    }
    // 3) 退回到脚本记录的最近一次
    const cur = (window.__fmCurrentModel || '').toString();
    return normalizeModelId(cur);
  }

  function updateStandaloneToggleLabel() {
    const btn = document.getElementById('fm-standalone-toggle');
    if (!btn) return;
    const id = getCurrentModelIdForDisplay();
    const name = id ? prettyName(id) : '选择模型';
    btn.textContent = name;
    try { btn.setAttribute('title', `当前模型：${name}`); } catch {}
  }

  function updateStandaloneSelection(menu) {
    if (!menu) return;
    const current = normalizeModelId((window.__fmCurrentModel || '') || (forceModelSticky || ''));
    menu.querySelectorAll('.__fm-standalone-item').forEach((el) => {
      const id = normalizeModelId(el.getAttribute('data-model-id') || '');
      el.classList.toggle('is-active', !!current && id === current);
    });
  }

  function hideStandaloneMenu() {
    const menu = document.getElementById('fm-standalone-menu');
    if (menu) menu.style.display = 'none';
  }

  function toggleStandaloneMenu() {
    const menu = document.getElementById('fm-standalone-menu');
    if (!menu) return;
    const show = menu.style.display === 'none' || !menu.style.display;
    if (show) {
      buildStandaloneMenuItems(menu);
      updateStandaloneSelection(menu);
      menu.style.display = '';
    } else {
      menu.style.display = 'none';
    }
  }

  function ensureStandaloneSwitcher() {
    const exists = document.getElementById('fm-standalone-switcher');
    const need = !hasNativeSwitcherVisible();
    if (!need) {
      if (exists) exists.style.display = 'none';
      return;
    }
    let box = exists;
    if (!box) {
      box = document.createElement('div');
      box.id = 'fm-standalone-switcher';
      box.style.position = 'fixed';
      box.style.left = '16px';
      box.style.top = '16px';
      box.style.zIndex = '9999999999';
      box.style.fontSize = '14px';
      box.style.userSelect = 'none';
      box.style.pointerEvents = 'auto';
      const btn = document.createElement('button');
      btn.id = 'fm-standalone-toggle';
      btn.type = 'button';
      btn.style.padding = '4px 10px';
      btn.style.borderRadius = '8px';
      btn.style.border = '1px solid var(--token-border, rgba(0,0,0,0.1))';
      btn.style.background = 'var(--token-surface-primary, #fff)';
      btn.style.color = 'var(--token-text-primary, #111)';
      btn.style.boxShadow = '0 2px 8px rgba(0,0,0,0.08)';
      btn.style.fontSize = '12px';
      btn.style.fontWeight = '500';
      btn.style.maxWidth = '240px';
      btn.style.whiteSpace = 'nowrap';
      btn.style.overflow = 'hidden';
      btn.style.textOverflow = 'ellipsis';
      btn.addEventListener('click', (e) => { e.stopPropagation(); toggleStandaloneMenu(); });
      const menu = document.createElement('div');
      menu.id = 'fm-standalone-menu';
      menu.style.position = 'absolute';
      menu.style.left = '0';
      menu.style.top = '42px';
      menu.style.minWidth = '180px';
      menu.style.maxHeight = '60vh';
      menu.style.overflow = 'auto';
      menu.style.padding = '6px';
      menu.style.borderRadius = '12px';
      menu.style.background = 'var(--token-surface-primary, #fff)';
      menu.style.border = '1px solid var(--token-border, rgba(0,0,0,0.12))';
      menu.style.boxShadow = '0 8px 24px rgba(0,0,0,0.12)';
      menu.style.display = 'none';
      // click outside to close
      document.addEventListener('click', (ev) => {
        const t = ev.target;
        if (!t || !(t instanceof Element)) return;
        if (t.closest('#fm-standalone-switcher')) return;
        hideStandaloneMenu();
      }, { capture: true });
      box.appendChild(btn);
      box.appendChild(menu);
      (document.body || document.documentElement).appendChild(box);
      // style for items
      const style = document.getElementById('fm-standalone-style') || document.createElement('style');
      style.id = 'fm-standalone-style';
      style.textContent = `
        #fm-standalone-menu { font-size: 14px; }
        #fm-standalone-menu .__fm-standalone-item {
          padding: 8px 10px; border-radius: 8px; cursor: pointer;
          color: var(--token-text-primary, #111);
        }
        #fm-standalone-menu .__fm-standalone-item:hover {
          background: var(--token-surface-secondary, rgba(0,0,0,0.04));
        }
        #fm-standalone-menu .__fm-standalone-item.is-active {
          background: var(--token-surface-brand, #10a37f); color: #fff;
        }
      `;
      document.documentElement.appendChild(style);
      // 初始化按钮显示文案
      try { updateStandaloneToggleLabel(); } catch {}
    }
    box.style.display = '';
  }
  function positionBadgeNearSwitcher() {
    const b = ensureInterceptBadge();
    if (!b || b.style.display === 'none') return; // 不显示时无需定位
    const btn = getVisibleSwitcherBtn();
    if (!btn) {
      // 找不到目标时，回到左上角不遮挡
      b.style.left = '10px';
      b.style.top = '10px';
      b.style.transform = 'none';
      return;
    }
    const r = btn.getBoundingClientRect();
    const left = Math.min(r.right + 8, (window.innerWidth || 0) - 10 - b.offsetWidth);
    const top = Math.max(10, Math.min(r.top + r.height / 2, (window.innerHeight || 0) - 10));
    b.style.left = `${Math.max(10, left)}px`;
    b.style.top = `${top}px`;
    b.style.transform = 'translateY(-50%)';
  }
  function scheduleReposition() {
    if (repositionTimer) cancelAnimationFrame(repositionTimer);
    repositionTimer = requestAnimationFrame(positionBadgeNearSwitcher);
  }
  function updateInterceptBadge(state = 'auto') {
    const b = ensureInterceptBadge();
    const txt = b.querySelector('#fm-intercept-text');
    const modelName = prettyName(forceModelSticky || '');
    const buttons = b.querySelectorAll('button');
    const cancelBtn = buttons[0];

    if (state === 'off' || !forceModelSticky) {
      b.style.display = 'none';
      try { FM.info('badge off'); } catch {}
      return;
    }
    // on
    b.style.display = '';
    b.style.background = 'var(--token-surface-brand, #10a37f)';
    txt.textContent = `常驻模型：${modelName}`;
    if (cancelBtn) cancelBtn.style.display = '';
    scheduleReposition();
    try { FM.info('badge show ->', modelName); } catch {}
  }
  const CONVO_RE = /\/backend-api\/(f\/)?conversation(?:$|\?)/;
  const BACKEND_RE = /\/backend-api\//i;
  const ANALYTICS_RE = /\/ces\/v1\/t(?:$|[/?#])/;
  const origFetch = W.fetch;
  // 判断是否为 JSON 请求体（尽量避免对 multipart/form-data 等误判导致的 JSON 解析报错）
  function isJsonRequest(req, init, bodyTxt) {
    try {
      const h = (req && req.headers) ? req.headers : (init && init.headers);
      let ct = '';
      if (h) {
        try { ct = (typeof h.get === 'function') ? (h.get('content-type') || '') : (Array.isArray(h) ? (h.find(([k]) => String(k).toLowerCase() === 'content-type')?.[1] || '') : (h['Content-Type'] || h['content-type'] || '')); } catch {}
      }
      ct = String(ct || '').toLowerCase();
      if (ct.includes('application/json')) return true;
      // 进一步兜底：快速判断文本是否像 JSON
      const t = String(bodyTxt || '').trim();
      return t.startsWith('{') || t.startsWith('[');
    } catch { return false; }
  }
  W.fetch = async function(input, init) {
    try {
      const req = (input instanceof Request) ? input : new Request(input, init);
      const url = req.url || (typeof input === 'string' ? input : '');
      const method = (req.method || (init && init.method) || 'GET').toUpperCase();
      const isBackend = BACKEND_RE.test(url);
      // 监听 Analytics：Model Switcher 事件，提取 target model 更新按钮文案
      if (ANALYTICS_RE.test(url) && method === 'POST') {
        try {
          const txt = await req.clone().text();
          if (txt) {
            try {
              const data = JSON.parse(txt);
              const evt = String(data?.event || '');
              const p = data?.properties || {};
              const to = p.to || p.model || p.value || p.selection || p.target;
              if (/Model\s*Switcher/i.test(evt) && to) {
                setAllSwitcherButtonsModel(to);
              }
            } catch {}
          }
        } catch {}
        // 透传
        return origFetch(input, init);
      }
      // 仅在 POST 且看起来是 JSON 的情况下再尝试解析与改写，避免无意义的解析报错
      if (method !== 'POST') { return origFetch(input, init); }
      let bodyTxt = '';
      try { bodyTxt = await req.clone().text(); } catch {}
      if (!bodyTxt) {
        // 没有可读 body：若 override armed，严格禁止 sticky 介入后台会话请求
        if (forceModelOverrideOnce && isBackend && Date.now() < stickyHardBlockUntil) {
          try { FM.info('fetch: hard block sticky (no body, backend)'); } catch {}
          return origFetch(input, init);
        }
        return origFetch(input, init);
      }
      if (!isJsonRequest(req, init, bodyTxt)) {
        // 非 JSON：若 override armed，严格禁止 sticky 介入后台会话请求
        if (forceModelOverrideOnce && isBackend && Date.now() < stickyHardBlockUntil) {
          try { FM.info('fetch: hard block sticky (non-json, backend)'); } catch {}
          return origFetch(input, init);
        }
        return origFetch(input, init);
      }
      try {
        const body = JSON.parse(bodyTxt);
        const wantOnce = forceModelOverrideOnce || null;
        const stickyBase = forceModelSticky || (inWindow() ? forceModel : null);
        const action = String(body?.action || '').toLowerCase();
        const hasModelKey = Object.prototype.hasOwnProperty.call(body || {}, 'model');
        const stickyActions = new Set(['variant','next','continue','create','creation','reply','submit','resume']);
        const CONV_URL_RE = /\/backend-api\/(f\/)?(conversation|chat|messages|compact)(?:$|[?/#])/i;
        const isConvPath = CONV_URL_RE.test(url);
        const looksLikeConversation = hasModelKey || stickyActions.has(action) || isConvPath || /\b(messages|input_text|prompt|conversation_id|parent_message_id)\b/.test(bodyTxt);
        const looksLikeGeneration = isConvPath && (hasModelKey || stickyActions.has(action) || /\b(messages|input_text|prompt)\b/.test(bodyTxt));

        // 0) 硬阻断：override armed 时，无论是否能改写 body，都阻断 sticky
        const hardBlockSticky = !!(wantOnce && Date.now() < stickyHardBlockUntil);

        // 1) 重试覆盖：严格要求命中“会话端点”才消耗与改写；若未命中则不消耗，但 sticky 也不介入（硬阻断）
        if (wantOnce && isConvPath && looksLikeGeneration) {
          const old = body.model;
          body.model = wantOnce;
          const newTxt = JSON.stringify(body);
          // 复制 headers，确保为 JSON，并避免遗留 content-length
          const headers = new Headers(req.headers || (init && init.headers) || undefined);
          try { headers.set('content-type', 'application/json'); headers.delete('content-length'); } catch {}
          const newInit = {
            method: req.method || (init && init.method) || 'POST',
            headers,
            body: newTxt,
            credentials: req.credentials,
            cache: req.cache,
            mode: req.mode,
            redirect: req.redirect,
            referrer: req.referrer,
            referrerPolicy: req.referrerPolicy,
            integrity: req.integrity,
            keepalive: req.keepalive,
            signal: req.signal,
          };
          // 保留/补充 duplex 以兼容 Chrome 的半双工请求（站点常用于流式接口）
          try { if (init && 'duplex' in init) newInit.duplex = init.duplex; else newInit.duplex = 'half'; } catch {}
          try { FM.info(`rewrite model: ${old} -> ${body.model} | action=${body.action} | override=true`); } catch {}
          clearOverrideOnce();
          return origFetch(req.url, newInit);
        }

        // 2) 抑制常驻：在窗口期内，仅当命中真正的会话端点时才消耗一次
        if (suppressStickyUntil > 0) {
          const now = Date.now();
          if (now < suppressStickyUntil && looksLikeGeneration) {
            try { FM.info('suppress sticky for this conversation request | action=', action || '(n/a)'); } catch {}
            suppressStickyUntil = 0; // 仅消耗一次
            return origFetch(input, init);
          }
          // 过期自动清理
          if (now >= suppressStickyUntil) suppressStickyUntil = 0;
        }

        // 3) 常驻：仅对“会话端点”应用；当 override armed 且处于硬阻断窗口时，跳过 sticky
        if (stickyBase && looksLikeGeneration && !(forceModelOverrideOnce && hardBlockSticky)) {
          const old = body.model;
          body.model = stickyBase;
          const newTxt = JSON.stringify(body);
          const headers = new Headers(req.headers || (init && init.headers) || undefined);
          try { headers.set('content-type', 'application/json'); headers.delete('content-length'); } catch {}
          const newInit = {
            method: req.method || (init && init.method) || 'POST',
            headers,
            body: newTxt,
            credentials: req.credentials,
            cache: req.cache,
            mode: req.mode,
            redirect: req.redirect,
            referrer: req.referrer,
            referrerPolicy: req.referrerPolicy,
            integrity: req.integrity,
            keepalive: req.keepalive,
            signal: req.signal,
          };
          try { if (init && 'duplex' in init) newInit.duplex = init.duplex; else newInit.duplex = 'half'; } catch {}
          try { FM.info(`rewrite model: ${old} -> ${body.model} | action=${body.action} | sticky=true`); } catch {}
          return origFetch(req.url, newInit);
        }

        // override armed 但未命中会话请求：避免 sticky 介入，透传
        if (forceModelOverrideOnce && hardBlockSticky && isBackend) {
          try { FM.info('fetch: override armed, skip sticky (backend pass-through)'); } catch {}
          return origFetch(input, init);
        }
      } catch (e) {
        // 仅在看起来是会话相关接口时提示解析问题；其他 POST（如上传/打点）静默忽略
        try {
          const looksLikeConv = /\/backend-api\//i.test(req.url || '') || /\b(messages|input_text|prompt)\b/.test(bodyTxt || '');
          if (looksLikeConv) FM.warn('rewrite parse error', e?.message || e);
        } catch {}
      }
      return origFetch(input, init);
    } catch (err) {
      return origFetch(input, init);
    }
  };

  // 在“重试模型选择器”构造一个与原生风格一致的快捷项，
  // 点击后：设置“常驻强制模型” -> 更新按钮文案 -> 触发原生项或重试。
  function createVariantMenuItem({label, sub, slug}) {
    const span = document.createElement('span');
    const item = document.createElement('div');
    item.setAttribute('role', 'menuitem');
    item.setAttribute('tabindex', '0');
    item.className = 'group __menu-item';
    item.dataset.orientation = 'vertical';
    item.setAttribute('data-radix-collection-item', '');
    const subLine = sub ? `<div class="not-group-data-disabled:text-token-text-tertiary leading-dense mb-0.5 text-xs group-data-sheet-item:mt-0.5 group-data-sheet-item:mb-0">${sub}</div>` : '';
    item.innerHTML = `
      <div class="min-w-0">
        <div class="flex min-w-0 grow items-center gap-2.5 group-data-no-contents-gap:gap-0">
          <div class="truncate">${label}</div>
        </div>
        ${subLine}
      </div>
    `;
    const onChoose = (ev) => {
      ev.preventDefault(); ev.stopPropagation();
      const targetModel = slug || label;
      try { FM.info('variant choose -> override once', targetModel); } catch {}
      // 重试菜单：仅设置一次性覆盖，优先级高于常驻；消耗后恢复常驻
      setOverrideOnce(targetModel);
      // 同时抑制一次常驻，防止在极端情况下（如请求体非 JSON/解析失败）仍被常驻覆盖
      suppressStickyNext('variant-quick');
      // 兼容旧的 2 秒时间窗策略，作为兜底（与一次性覆盖共同作用）
      try { setForce(targetModel, 2000); } catch {}
      setTimeout(() => {
        const ok = clickNativeOrRetry();
        if (!ok) console.warn('[fm] 没能自动触发；你可手动点一次重试，窗口仍然生效。');
      }, 10);
    };
    item.addEventListener('click', onChoose);
    span.appendChild(item);
    span.dataset.fmItem = '1';
    return span;
  }
  // 在“重试模型选择器”中找到锚点项，并在其后插入若干快捷项。
  function enhanceVariantMenu(root) {
    if (!root || root.dataset.fmAugmented) return;
    if (!isVariantMenu(root)) return;
    root.dataset.fmAugmented = '1';
    lastVariantMenuRoot = root;
    if (root.querySelector('[data-fmItem="1"]')) return;
    const items = root.querySelectorAll('[role^="menuitem"]');
    let anchor = null;
    const NATIVE_ANCHOR_TEXTS = [/^o4-mini$/i, /^gpt-4o$/i, /^gpt-4\.?1$/i];
    for (const re of NATIVE_ANCHOR_TEXTS) {
      anchor = Array.from(items).find(el => re.test(getItemLabel(el)));
      if (anchor) break;
    }
    if (!anchor) return;
    const anchorSpan = anchor.closest('span') || anchor;
    const QUICK_MODELS = (() => {
      const list = [];
      const seen = new Set();
      const desired = getDesiredOrder();
      for (const id of desired) {
        if (seen.has(id)) continue;
        seen.add(id);
        if (!isModelAllowed(id)) continue;
        list.push({ label: prettyName(id), slug: id });
      }
      return list;
    })();
    QUICK_MODELS.forEach(q => {
      const node = createVariantMenuItem(q);
      anchorSpan.parentNode.insertBefore(node, anchorSpan.nextSibling);
    });

    // 捕获原生菜单项点击：当用户点击 Auto/Instant/Thinking/Pro/Ultra 等原生项时，
    // 不去猜测具体模型，而是抑制一次常驻改写，让站点自带的模型值生效。
    if (!root.dataset.fmBindNativeClick) {
      const handler = (ev) => {
        const t = ev.target;
        if (!t || !(t instanceof Element)) return;
        // 排除我们插入的快捷项
        if (t.closest('[data-fmItem="1"]')) return;
        const item = t.closest('[role^="menuitem"]');
        if (!item) return;
        const label = getItemLabel(item);
        // 原生变体项：无条件抑制一次常驻，让原生本次生效
        suppressStickyNext(label);
      };
      root.addEventListener('click', handler, { capture: true });
      root.addEventListener('pointerdown', handler, { capture: true });
      root.dataset.fmBindNativeClick = '1';
    }
  }

  // ---------------- 观察与启动 ----------------
  // 与“顶部切换按钮”绑定的观察器：
  // - 通过按钮 id → 菜单 aria-labelledby 关联，拿到对应菜单；
  // - 根据菜单类型路由到 addCustomModels（Main）或 enhanceVariantMenu（重试）。
  function installMenuObserverFor(triggerBtn) {
    const debounced = debounce(() => {
      const menu = findAssociatedMenu(triggerBtn);
      if (menu && isOfficialModelMenu(menu)) {
        addCustomModels(menu);
        ensureStickyReorder(menu);
      }
    }, 50);
    const bodyObserver = new MutationObserver(() => { debounced(); });
    bodyObserver.observe(document.body, { childList: true, subtree: true });
    debounced();
    const attrObs = new MutationObserver(() => debounced());
    attrObs.observe(triggerBtn, { attributes: true, attributeFilter: ['aria-expanded', 'id'] });
  }

  // 启动：
  // - 监听并附着顶部切换按钮，首次点击时安装菜单观察器；
  // - 全局 MutationObserver 兜底，发现任意新菜单后按类型处理；
  // - 监听 URL 变化同步按钮文案。
  function bootstrap() {
    // 首次运行层级选择（仅一次）
    ensureTierChosen();
    const attach = (btn) => {
      if (!(btn instanceof HTMLElement)) return;
      if (btn.dataset.orderMergedEnhanced === 'true') return;
      btn.dataset.orderMergedEnhanced = 'true';
      btn.addEventListener('click', () => { installMenuObserverFor(btn); }, { once: true });
      updateAllSwitcherButtonsFromURL();
    };
    document.querySelectorAll(`[data-testid="${TEST_ID_SWITCHER}"]`).forEach(attach);
    const obsButtons = new MutationObserver(() => { document.querySelectorAll(`[data-testid="${TEST_ID_SWITCHER}"]`).forEach(attach); });
    obsButtons.observe(document.body, { childList: true, subtree: true });
    // 独立模型选择器：在无官方按钮时提供入口
    ensureStandaloneSwitcher();
    const obsStandalone = new MutationObserver(() => { ensureStandaloneSwitcher(); scheduleReposition(); });
    obsStandalone.observe(document.body, { childList: true, subtree: true });

    // 全局兜底：任意新开的菜单，按类型分别处理（Main/重试）
    const menuObserver = new MutationObserver((mutations) => {
      for (const m of mutations) {
        for (const node of m.addedNodes) {
          if (!(node instanceof HTMLElement)) continue;
          const candidates = [];
          if (node.matches?.('[role="menu"], [role="listbox"], [data-radix-menu-content]')) candidates.push(node);
          node.querySelectorAll?.('[role="menu"], [role="listbox"], [data-radix-menu-content]').forEach((el) => candidates.push(el));
          for (const el of candidates) {
            const menu = el.getAttribute('role') ? el : el.querySelector?.('[role="menu"], [role="listbox"]');
            if (!menu) continue;
            if (isOfficialModelMenu(menu)) {
              addCustomModels(menu);
              ensureStickyReorder(menu);
            } else if (isVariantMenu(menu)) {
              enhanceVariantMenu(menu);
            }
          }
        }
      }
    });
    menuObserver.observe(document.body, { childList: true, subtree: true });

    window.addEventListener('popstate', () => { updateAllSwitcherButtonsFromURL(); scheduleReposition(); });
    window.addEventListener('pushstate', () => { updateAllSwitcherButtonsFromURL(); scheduleReposition(); });
    window.addEventListener('locationchange', () => { updateAllSwitcherButtonsFromURL(); scheduleReposition(); });
    window.addEventListener('resize', scheduleReposition, { passive: true });
    window.addEventListener('scroll', scheduleReposition, { passive: true, capture: true });
    // 确保拦截状态徽标已就绪并尝试定位
    try { ensureInterceptBadge(); scheduleReposition(); } catch {}
  }

  if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', bootstrap, { once: true });
  } else {
    bootstrap();
  }

  // 样式：保证自定义项文本色 + 隐藏特定分隔线
  const style = document.createElement('style');
  style.id = 'chatgpt-order-merged-style';
  style.textContent = `
    [data-custom-model] { color: var(--token-text-primary, var(--text-primary, inherit)) !important; }
    [data-custom-model] * { color: inherit !important; }
    [data-testid="Legacy models-submenu"] { display: none !important; }
    [role="separator"].bg-token-border-default.h-px.mx-4.my-1 { display: none !important; }
  `;
  document.documentElement.appendChild(style);

  // 额外兜底：拦截 XHR（部分页面可能用 XHR 发送对话请求）
  try {
    const P = XMLHttpRequest.prototype;
    const origOpen = P.open;
    const origSend = P.send;
    const origSetHeader = P.setRequestHeader;
    P.open = function(method, url, async, user, password) {
      try {
        this.__fm = this.__fm || {};
        this.__fm.method = String(method || '').toUpperCase();
        this.__fm.url = String(url || '');
        this.__fm.headers = {};
      } catch {}
      return origOpen.apply(this, arguments);
    };
    P.setRequestHeader = function(k, v) {
      try {
        if (this.__fm && this.__fm.headers) { this.__fm.headers[String(k || '').toLowerCase()] = String(v || ''); }
      } catch {}
      return origSetHeader.apply(this, arguments);
    };
    P.send = function(body) {
      try {
        const info = this.__fm || {};
        const method = String(info.method || '').toUpperCase();
        const url = String(info.url || '');
        const isBackend = BACKEND_RE.test(url);
        if (method !== 'POST') return origSend.apply(this, arguments);

        let txt = null;
        if (typeof body === 'string') txt = body;
        // 仅处理字符串 JSON；其他类型（FormData/Blob）不改写，保持安全
        if (!txt) {
          // override armed → 硬阻断 sticky，对 backend 直接透传
          if (forceModelOverrideOnce && isBackend && Date.now() < stickyHardBlockUntil) {
            try { FM.info('xhr: hard block sticky (non-string body, backend)'); } catch {}
            return origSend.apply(this, arguments);
          }
          return origSend.apply(this, arguments);
        }

        // 快速判定是否像 JSON
        const likeJson = /^\s*[{\[]/.test(txt);
        if (!likeJson) {
          if (forceModelOverrideOnce && isBackend && Date.now() < stickyHardBlockUntil) {
            try { FM.info('xhr: hard block sticky (non-json text)'); } catch {}
            return origSend.apply(this, arguments);
          }
          return origSend.apply(this, arguments);
        }

        try {
          const data = JSON.parse(txt);
          const wantOnce = forceModelOverrideOnce || null;
          const stickyBase = forceModelSticky || (inWindow() ? forceModel : null);
          const action = String(data?.action || '').toLowerCase();
          const hasModelKey = Object.prototype.hasOwnProperty.call(data || {}, 'model');
          const stickyActions = new Set(['variant','next','continue','create','creation','reply','submit','resume']);
          const CONV_URL_RE = /\/backend-api\/(f\/)?(conversation|chat|messages|compact)(?:$|[?/#])/i;
          const isConvPath = CONV_URL_RE.test(url);
          const looksLikeGeneration = isConvPath && (hasModelKey || stickyActions.has(action) || /\b(messages|input_text|prompt)\b/.test(txt));
          const hardBlockSticky = !!(wantOnce && Date.now() < stickyHardBlockUntil);

          // 优先：override once
          if (wantOnce && isConvPath && looksLikeGeneration) {
            const old = data.model;
            data.model = wantOnce;
            const newTxt = JSON.stringify(data);
            try { this.setRequestHeader('content-type', 'application/json'); } catch {}
            try { FM.info(`xhr rewrite model: ${old} -> ${data.model} | action=${data.action} | override=true`); } catch {}
            clearOverrideOnce();
            return origSend.call(this, newTxt);
          }

          // 抑制 sticky 窗口
          if (suppressStickyUntil > 0) {
            const now = Date.now();
            if (now < suppressStickyUntil && looksLikeGeneration) {
              try { FM.info('xhr suppress sticky for this conversation request'); } catch {}
              suppressStickyUntil = 0;
              return origSend.apply(this, arguments);
            }
            if (now >= suppressStickyUntil) suppressStickyUntil = 0;
          }

          // sticky：在无硬阻断时应用
          if (stickyBase && looksLikeGeneration && !(forceModelOverrideOnce && hardBlockSticky)) {
            const old = data.model;
            data.model = stickyBase;
            const newTxt = JSON.stringify(data);
            try { this.setRequestHeader('content-type', 'application/json'); } catch {}
            try { FM.info(`xhr rewrite model: ${old} -> ${data.model} | action=${data.action} | sticky=true`); } catch {}
            return origSend.call(this, newTxt);
          }

          // override armed 未命中：阻断 sticky，透传
          if (forceModelOverrideOnce && hardBlockSticky && isBackend) {
            try { FM.info('xhr: override armed, skip sticky (backend pass-through)'); } catch {}
            return origSend.apply(this, arguments);
          }

        } catch (e) {
          try { FM.warn('xhr parse error', e?.message || e); } catch {}
        }
        return origSend.apply(this, arguments);
      } catch (err) {
        return origSend.apply(this, arguments);
      }
    };
  } catch {}
})();