Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

46.4 KB
Raw Blame
/**
 * providerModelMemory.test.ts
 * ---------------------------------------------------------------------------
 * 回归 state/providerModelMemory.ts 的核心约定:
 *   1. 默认无记录 → getProviderModelChoice 返回 undefined
 *   2. set/get 往返 + localStorage 持久化(模拟 app 重启后恢复)
 *   3. 同一 agent/model 跨来源共享,不同 agent 仍隔离
 *   4. 同值写入短路(不抛,值保持)
 *   5. 空 providerId / model / effort 入参被静默忽略
 *   6. schema 损坏的 localStorage → 静默回退空表,不抛
 *
 * 项目 vitest env=node,无 window。沿用 newMakerDraft.test.ts 的最小 localStorage stub。
 */

import { describe, it, expect, beforeEach, vi } from 'vitest';

class MemLocalStorage {
  private store = new Map<string, string>();
  private writesFail = false;
  getItem(k: string): string | null {
    return this.store.has(k) ? (this.store.get(k) as string) : null;
  }
  setItem(k: string, v: string): void {
    if (this.writesFail) throw new Error('simulated localStorage write failure');
    this.store.set(k, v);
  }
  removeItem(k: string): void {
    this.store.delete(k);
  }
  clear(): void {
    this.store.clear();
  }
  setWritesFail(writesFail: boolean): void {
    this.writesFail = writesFail;
  }
}

let memStorage: MemLocalStorage;

beforeEach(() => {
  memStorage = new MemLocalStorage();
  vi.stubGlobal('window', { localStorage: memStorage });
  vi.stubGlobal('localStorage', memStorage);
  vi.resetModules();
});

async function loadModule() {
  return await import('@/state/providerModelMemory');
}

describe('providerModelMemory store', () => {
  // Standard tier: speed presets must survive persistence without collapsing Ultrafast to true.
  it('preserves Ultrafast in saved model presets and host snapshots', async () => {
    const m = await loadModule();
    m.setProviderModelFast('codex', 'openai', 'gpt-6-astra', 'ultrafast');
    expect(m.getProviderModelFast('codex', 'openai', 'gpt-6-astra')).toBe('ultrafast');
    expect(m.snapshotForSeed()['codex:*']?.fastByModel['gpt-6-astra']).toBe('ultrafast');
    const saved = memStorage.getItem(m.__STORAGE_KEY)!;
    m.__resetForTest();
    memStorage.setItem(m.__STORAGE_KEY, saved);
    expect(m.getProviderModelFast('codex', 'openai', 'gpt-6-astra')).toBe('ultrafast');
  });

  it('默认无记录:getProviderModelChoice 返回 undefined', async () => {
    const { getProviderModelChoice, hasAnyProviderModelOverride } = await loadModule();
    expect(getProviderModelChoice('claude-code', 'xd')).toBeUndefined();
    expect(getProviderModelChoice('codex', 'openai')).toBeUndefined();
    expect(hasAnyProviderModelOverride()).toBe(false);
  });

  it('仅有 effort 或 Fast 记忆也视为既有模型自定义', async () => {
    const effortMemory = await loadModule();
    effortMemory.setProviderModelEffort('claude-code', 'anthropic', 'claude-opus-4-8', 'high');
    expect(effortMemory.hasAnyProviderModelOverride()).toBe(true);

    effortMemory.__resetForTest();
    effortMemory.setProviderModelFast('codex', 'openai', 'gpt-5.6-sol', false);
    expect(effortMemory.hasAnyProviderModelOverride()).toBe(true);
  });

  it('按 dataOwnerId 隔离 override,旧全局快照只由首个 owner 认领', async () => {
    memStorage.setItem(
      'xdt:providerModelMemory:v2',
      JSON.stringify({
        'claude-code:anthropic': {
          lastModel: '',
          effortByModel: { 'claude-opus-4-8': 'high' },
          fastByModel: {},
          thinkingByModel: {},
        },
      }),
    );
    const m = await loadModule();
    m.setProviderModelMemoryOwner('owner-a');
    expect(m.hasAnyProviderModelOverride()).toBe(true);
    expect(memStorage.getItem('xdt:providerModelMemory:v2')).toBeNull();

    m.setProviderModelMemoryOwner('owner-b');
    expect(m.hasAnyProviderModelOverride()).toBe(false);
    m.setProviderModelFast('codex', 'openai', 'gpt-5.6-sol', false);
    expect(m.hasAnyProviderModelOverride()).toBe(true);

    m.setProviderModelMemoryOwner('owner-a');
    expect(m.getProviderModelEffort('claude-code', 'anthropic', 'claude-opus-4-8')).toBe('high');
    expect(m.getProviderModelFast('codex', 'openai', 'gpt-5.6-sol')).toBeUndefined();
  });

  it('同 owner 的外部写入刷新空缓存并通知订阅者,其他 owner 事件不串入', async () => {
    let onStorage: ((event: StorageEvent) => void) | undefined;
    vi.stubGlobal('window', {
      localStorage: memStorage,
      addEventListener: (type: string, listener: EventListener) => {
        if (type === 'storage') onStorage = listener as (event: StorageEvent) => void;
      },
      removeEventListener: vi.fn(),
    });
    vi.resetModules();

    const m = await loadModule();
    m.setProviderModelMemoryOwner('owner-a');
    expect(m.hasAnyProviderModelOverride()).toBe(false); // 窗口 B 先以空缓存启动。
    const seen = vi.fn();
    m.subscribeProviderModelMemory(seen);

    const ownerAKey = `${m.__STORAGE_KEY}:owner-a`;
    memStorage.setItem(
      ownerAKey,
      JSON.stringify({
        'codex:openai': {
          lastModel: '',
          effortByModel: { 'gpt-5.6-sol': 'xhigh' },
          fastByModel: { 'gpt-5.6-sol': true },
          thinkingByModel: {},
        },
      }),
    );
    onStorage?.({ key: ownerAKey, newValue: '{ stale event payload }' } as StorageEvent);

    expect(seen).toHaveBeenCalledTimes(1);
    expect(m.hasAnyProviderModelOverride()).toBe(true);
    expect(m.getProviderModelEffort('codex', 'openai', 'gpt-5.6-sol')).toBe('xhigh');
    expect(m.getProviderModelFast('codex', 'openai', 'gpt-5.6-sol')).toBe(true);

    // 相同持久化真相的迟到事件不应重复 bump modelPresetVersion。
    onStorage?.({ key: ownerAKey, newValue: '{ older payload }' } as StorageEvent);
    onStorage?.({
      key: ownerAKey,
      storageArea: {} as Storage,
    } as StorageEvent);
    expect(seen).toHaveBeenCalledTimes(1);

    memStorage.setItem(
      `${m.__STORAGE_KEY}:owner-b`,
      JSON.stringify({
        'claude-code:anthropic': {
          lastModel: '',
          effortByModel: { 'claude-opus-4-8': 'low' },
          fastByModel: {},
          thinkingByModel: {},
        },
      }),
    );
    onStorage?.({ key: `${m.__STORAGE_KEY}:owner-b` } as StorageEvent);
    expect(seen).toHaveBeenCalledTimes(1);
    expect(m.getProviderModelEffort('claude-code', 'anthropic', 'claude-opus-4-8')).toBeUndefined();

    // owner 已切换后,旧 owner 的迟到事件不能刷新新 owner 缓存。
    m.setProviderModelMemoryOwner('owner-c');
    seen.mockClear();
    onStorage?.({ key: ownerAKey } as StorageEvent);
    expect(seen).not.toHaveBeenCalled();
    expect(m.hasAnyProviderModelOverride()).toBe(false);
  });

  it('写入前重读 owner 分区,不用空缓存覆盖外部 effort/Fast', async () => {
    const m = await loadModule();
    m.setProviderModelMemoryOwner('owner-a');
    expect(m.hasAnyProviderModelOverride()).toBe(false); // 窗口 B 的旧缓存。

    const ownerAKey = `${m.__STORAGE_KEY}:owner-a`;
    memStorage.setItem(
      ownerAKey,
      JSON.stringify({
        'claude-code:anthropic': {
          lastModel: '',
          effortByModel: { 'claude-opus-4-8': 'high' },
          fastByModel: { 'claude-opus-4-8': true },
          thinkingByModel: {},
        },
      }),
    );

    // storage 事件尚未送达时,窗口 B 又写另一条;整表写回仍须保留窗口 A 的两项 override。
    m.setProviderModelThinking('pi', 'xd', 'glm-5.3-flash', true);
    const persisted = JSON.parse(memStorage.getItem(ownerAKey) ?? '{}') as Record<
      string,
      {
        effortByModel: Record<string, string>;
        fastByModel: Record<string, boolean>;
        thinkingByModel: Record<string, boolean>;
      }
    >;
    expect(persisted['claude-code:anthropic']?.effortByModel['claude-opus-4-8']).toBe('high');
    expect(persisted['claude-code:anthropic']?.fastByModel['claude-opus-4-8']).toBe(true);
    expect(persisted['pi:xd']?.thinkingByModel['glm-5.3-flash']).toBe(true);
  });

  it('写前读到外部同值时也刷新本窗口缓存和订阅者', async () => {
    const m = await loadModule();
    m.setProviderModelMemoryOwner('owner-a');
    expect(m.hasAnyProviderModelOverride()).toBe(false);
    const seen = vi.fn();
    m.subscribeProviderModelMemory(seen);

    const ownerAKey = `${m.__STORAGE_KEY}:owner-a`;
    memStorage.setItem(
      ownerAKey,
      JSON.stringify({
        'codex:openai': {
          lastModel: '',
          effortByModel: { 'gpt-5.6-sol': 'xhigh' },
          fastByModel: {},
          thinkingByModel: {},
        },
      }),
    );

    // storage 事件尚未到达;同值写虽无需再落盘,但 freshMap 已看到的真相必须立即被采纳。
    m.setProviderModelEffort('codex', 'openai', 'gpt-5.6-sol', 'xhigh');
    expect(m.getProviderModelEffort('codex', 'openai', 'gpt-5.6-sol')).toBe('xhigh');
    expect(seen).toHaveBeenCalledTimes(1);
  });

  it('写盘失败后继续保留当前 owner 的新 override,可写时完整补落盘', async () => {
    const m = await loadModule();
    m.setProviderModelMemoryOwner('owner-a');
    const ownerAKey = `${m.__STORAGE_KEY}:owner-a`;
    memStorage.setItem(
      ownerAKey,
      JSON.stringify({
        'claude-code:anthropic': {
          lastModel: '',
          effortByModel: { 'claude-opus-4-8': 'medium' },
          fastByModel: {},
          thinkingByModel: {},
        },
      }),
    );

    memStorage.setWritesFail(true);
    m.setProviderModelFast('claude-code', 'anthropic', 'claude-opus-4-8', true);
    m.setProviderModelEffort('codex', 'openai', 'gpt-5.6-sol', 'xhigh');
    expect(m.getProviderModelFast('claude-code', 'anthropic', 'claude-opus-4-8')).toBe(true);
    expect(m.getProviderModelEffort('codex', 'openai', 'gpt-5.6-sol')).toBe('xhigh');

    memStorage.setWritesFail(false);
    // 窗口 A 在 B 写盘失败期间成功写入另一项;B 恢复后必须在这份新盘面上重放自己的 op。
    memStorage.setItem(
      ownerAKey,
      JSON.stringify({
        'claude-code:anthropic': {
          lastModel: '',
          effortByModel: { 'claude-opus-4-8': 'medium' },
          fastByModel: {},
          thinkingByModel: {},
        },
        'claude-code:xd': {
          lastModel: '',
          effortByModel: { 'claude-haiku-4-5': 'low' },
          fastByModel: {},
          thinkingByModel: {},
        },
        'codex:openai': {
          lastModel: 'gpt-5.5',
          effortByModel: { 'gpt-5.5': 'medium' },
          fastByModel: {},
          thinkingByModel: {},
        },
        'codex:*': {
          lastModel: '',
          effortByModel: {},
          fastByModel: { 'gpt-5.6-sol': false },
          thinkingByModel: {},
        },
      }),
    );
    m.setProviderModelThinking('pi', 'xd', 'glm-5.3-flash', true);
    const persisted = JSON.parse(memStorage.getItem(ownerAKey) ?? '{}') as Record<
      string,
      {
        effortByModel: Record<string, string>;
        fastByModel: Record<string, boolean>;
        thinkingByModel: Record<string, boolean>;
      }
    >;
    expect(persisted['claude-code:anthropic']?.effortByModel['claude-opus-4-8']).toBe('medium');
    expect(persisted['claude-code:anthropic']?.fastByModel['claude-opus-4-8']).toBe(true);
    expect(persisted['claude-code:xd']?.effortByModel['claude-haiku-4-5']).toBe('low');
    expect(persisted['codex:openai']?.effortByModel['gpt-5.6-sol']).toBe('xhigh');
    expect(persisted['codex:openai']?.effortByModel['gpt-5.5']).toBe('medium');
    expect((persisted['codex:openai'] as { lastModel?: string })?.lastModel).toBe('gpt-5.5');
    expect(persisted['codex:*']?.fastByModel['gpt-5.6-sol']).toBe(false);
    expect(persisted['pi:xd']?.thinkingByModel['glm-5.3-flash']).toBe(true);
  });

  it('写盘失败的旧操作不覆盖另一窗口后来写入的同字段', async () => {
    const m = await loadModule();
    m.setProviderModelMemoryOwner('owner-a');
    const ownerAKey = `${m.__STORAGE_KEY}:owner-a`;

    memStorage.setWritesFail(true);
    m.setProviderModelFast('codex', 'openai', 'gpt-5.6-sol', true);

    memStorage.setWritesFail(false);
    // 窗口 A 后来明确把同一字段设为 false;B 的旧 pending=true 恢复时必须退休。
    memStorage.setItem(
      ownerAKey,
      JSON.stringify({
        'codex:openai': {
          lastModel: '',
          effortByModel: {},
          fastByModel: { 'gpt-5.6-sol': false },
          thinkingByModel: {},
        },
      }),
    );
    m.setProviderModelThinking('pi', 'xd', 'glm-5.3-flash', true);

    const persisted = JSON.parse(memStorage.getItem(ownerAKey) ?? '{}') as Record<
      string,
      { fastByModel: Record<string, boolean> }
    >;
    expect(persisted['codex:openai']?.fastByModel['gpt-5.6-sol']).toBe(false);
  });

  it('thinking 写盘失败后,另一窗口改了权威槽也必须让旧操作退休', async () => {
    const m = await loadModule();
    m.setProviderModelMemoryOwner('owner-a');
    const ownerAKey = `${m.__STORAGE_KEY}:owner-a`;

    memStorage.setWritesFail(true);
    m.setProviderModelThinking('pi', 'glm-coding-plan', 'glm-5.3-flash', true);

    memStorage.setWritesFail(false);
    // 窗口 A 把同一 (agent, model) 的权威槽 thinking 改成 false 并成功落盘。
    memStorage.setItem(
      ownerAKey,
      JSON.stringify({
        'pi:*': {
          lastModel: '',
          effortByModel: {},
          fastByModel: {},
          thinkingByModel: { 'glm-5.3-flash': false },
        },
      }),
    );
    // 触发一次读取,重放 pending;B 的旧 pending=true 必须退休,不覆盖窗口 A 的选择。
    m.setProviderModelThinking('claude-code', 'anthropic', 'claude-opus-5', true);
    const persisted = JSON.parse(memStorage.getItem(ownerAKey) ?? '{}') as Record<
      string,
      { thinkingByModel: Record<string, boolean> }
    >;
    expect(persisted['pi:*']?.thinkingByModel['glm-5.3-flash']).toBe(false);
  });

  it('选模写盘失败后再调 effort,不会丢失独立的 lastModel 意图', async () => {
    const m = await loadModule();
    m.setProviderModelMemoryOwner('owner-a');

    memStorage.setWritesFail(true);
    m.setProviderModelChoice('codex', 'openai', 'gpt-5.6-sol', 'high');
    m.setProviderModelEffort('codex', 'openai', 'gpt-5.6-sol', 'xhigh');

    memStorage.setWritesFail(false);
    m.setProviderModelThinking('pi', 'xd', 'glm-5.3-flash', true);
    expect(m.getProviderModelChoice('codex', 'openai')).toEqual({
      model: 'gpt-5.6-sol',
      effort: 'xhigh',
    });
  });

  it('冲突退休的旧 lastModel 基线不阻断后来更新的本地选模', async () => {
    const m = await loadModule();
    m.setProviderModelMemoryOwner('owner-a');
    const ownerAKey = `${m.__STORAGE_KEY}:owner-a`;
    memStorage.setItem(
      ownerAKey,
      JSON.stringify({
        'codex:openai': {
          lastModel: 'model-x',
          effortByModel: { 'model-x': 'medium' },
          fastByModel: {},
          thinkingByModel: {},
        },
      }),
    );

    memStorage.setWritesFail(true);
    m.setProviderModelChoice('codex', 'openai', 'model-a', 'high');

    memStorage.setWritesFail(false);
    memStorage.setItem(
      ownerAKey,
      JSON.stringify({
        'codex:openai': {
          lastModel: 'model-c',
          effortByModel: { 'model-c': 'low' },
          fastByModel: {},
          thinkingByModel: {},
        },
      }),
    );
    memStorage.setWritesFail(true);
    m.setProviderModelChoice('codex', 'openai', 'model-b', 'xhigh');

    memStorage.setWritesFail(false);
    m.setProviderModelThinking('pi', 'xd', 'glm-5.3-flash', true);
    expect(m.getProviderModelChoice('codex', 'openai')).toEqual({
      model: 'model-b',
      effort: 'xhigh',
    });
  });

  it('set/get 往返 + 跨重启持久化', async () => {
    const m1 = await loadModule();
    m1.setProviderModelChoice('claude-code', 'anthropic', 'claude-opus-4-8', 'high');
    expect(m1.getProviderModelChoice('claude-code', 'anthropic')).toEqual({
      model: 'claude-opus-4-8',
      effort: 'high',
    });

    // 模拟 app 重启(重置模块缓存后重新从 localStorage 加载)
    vi.resetModules();
    const m2 = await loadModule();
    expect(m2.getProviderModelChoice('claude-code', 'anthropic')).toEqual({
      model: 'claude-opus-4-8',
      effort: 'high',
    });
  });

  it('按 (agent, providerId) 分槽:xd 在 cc / codex 下互不覆盖', async () => {
    const m = await loadModule();
    m.setProviderModelChoice('claude-code', 'xd', 'claude-sonnet-4-6', 'medium');
    m.setProviderModelChoice('codex', 'xd', 'gpt-5.4', 'high');
    expect(m.getProviderModelChoice('claude-code', 'xd')).toEqual({
      model: 'claude-sonnet-4-6',
      effort: 'medium',
    });
    expect(m.getProviderModelChoice('codex', 'xd')).toEqual({
      model: 'gpt-5.4',
      effort: 'high',
    });
  });

  it('覆盖写:同一槽再次写入用新值', async () => {
    const m = await loadModule();
    m.setProviderModelChoice('claude-code', 'xd', 'claude-opus-4-8', 'high');
    m.setProviderModelChoice('claude-code', 'xd', 'claude-haiku-4-5', 'low');
    expect(m.getProviderModelChoice('claude-code', 'xd')).toEqual({
      model: 'claude-haiku-4-5',
      effort: 'low',
    });
  });

  it('同值写入短路:值保持不变,不抛', async () => {
    const m = await loadModule();
    m.setProviderModelChoice('codex', 'openai', 'gpt-5.4', 'high');
    expect(() => m.setProviderModelChoice('codex', 'openai', 'gpt-5.4', 'high')).not.toThrow();
    expect(m.getProviderModelChoice('codex', 'openai')).toEqual({
      model: 'gpt-5.4',
      effort: 'high',
    });
  });

  it('空 providerId / model / effort 入参被忽略', async () => {
    const m = await loadModule();
    m.setProviderModelChoice('claude-code', '', 'claude-opus-4-8', 'high');
    m.setProviderModelChoice('claude-code', 'anthropic', '', 'high');
    m.setProviderModelChoice('claude-code', 'anthropic', 'claude-opus-4-8', '');
    expect(m.getProviderModelChoice('claude-code', '')).toBeUndefined();
    expect(m.getProviderModelChoice('claude-code', 'anthropic')).toBeUndefined();
  });

  it('schema 损坏的 localStorage → 静默回退空表,不抛', async () => {
    memStorage.setItem('xdt:providerModelMemory:v2', '{ not valid json');
    vi.resetModules();
    const { getProviderModelChoice } = await loadModule();
    expect(getProviderModelChoice('claude-code', 'anthropic')).toBeUndefined();
  });
});

describe('providerModelMemory v2 —— (agent, model) 全局 effort + provider lastModel', () => {
  it('同一来源不同模型各记各的 effort,lastModel 切换不覆盖旧模型 effort', async () => {
    const m = await loadModule();
    m.setProviderModelChoice('claude-code', 'anthropic', 'claude-opus-4-8', 'high');
    m.setProviderModelChoice('claude-code', 'anthropic', 'claude-haiku-4-5', 'low');
    // opus 的 high 不因后写 haiku 而丢失
    expect(m.getProviderModelEffort('claude-code', 'anthropic', 'claude-opus-4-8')).toBe('high');
    expect(m.getProviderModelEffort('claude-code', 'anthropic', 'claude-haiku-4-5')).toBe('low');
    // getProviderModelChoice 返回该来源 lastModel + 其 effort
    expect(m.getProviderModelChoice('claude-code', 'anthropic')).toEqual({
      model: 'claude-haiku-4-5',
      effort: 'low',
    });
  });

  it('同一 agent/model 的 effort 跨来源共享(切来源不再换回旧档位)', async () => {
    const m = await loadModule();
    m.setProviderModelChoice('claude-code', 'anthropic', 'claude-opus-4-8', 'high');
    // 权威槽已由 anthropic 那笔写入播种,xd 读到同一份 —— 这正是「同模型换来源不变低」。
    expect(m.getProviderModelEffort('claude-code', 'xd', 'claude-opus-4-8')).toBe('high');
    // 另一个来源再选一次 = 覆盖权威值,两个来源一起变(单一真相)。
    m.setProviderModelChoice('claude-code', 'xd', 'claude-opus-4-8', 'medium');
    expect(m.getProviderModelEffort('claude-code', 'anthropic', 'claude-opus-4-8')).toBe('medium');
    expect(m.getProviderModelEffort('claude-code', 'xd', 'claude-opus-4-8')).toBe('medium');
    // agent 之间仍隔离:codex 的同名模型不吃 claude-code 的预设。
    expect(m.getProviderModelEffort('codex', 'openai', 'claude-opus-4-8')).toBeUndefined();
  });

  it('只编辑非选中模型的 effort 不会篡改该来源 lastModel', async () => {
    const m = await loadModule();
    m.setProviderModelChoice('claude-code', 'anthropic', 'claude-sonnet-4-6', 'medium');
    m.setProviderModelEffort('claude-code', 'anthropic', 'claude-opus-4-8', 'high');
    expect(m.getProviderModelChoice('claude-code', 'anthropic')).toEqual({
      model: 'claude-sonnet-4-6',
      effort: 'medium',
    });
    expect(m.getProviderModelEffort('claude-code', 'anthropic', 'claude-opus-4-8')).toBe('high');
    expect(m.getProviderModelEffort('claude-code', 'xd', 'claude-opus-4-8')).toBe('high');
  });

  it('getProviderModelEffort:未记录模型 / 空参 → undefined,其它来源读到同一份', async () => {
    const m = await loadModule();
    m.setProviderModelChoice('codex', 'openai', 'gpt-5.5', 'high');
    expect(m.getProviderModelEffort('codex', 'openai', 'gpt-5.5')).toBe('high');
    expect(m.getProviderModelEffort('codex', 'openai', 'unknown-model')).toBeUndefined();
    expect(m.getProviderModelEffort('codex', 'xd', 'gpt-5.5')).toBe('high');
    expect(m.getProviderModelEffort('codex', '', 'gpt-5.5')).toBeUndefined();
    expect(m.getProviderModelEffort('codex', 'openai', '')).toBeUndefined();
  });

  it('权威槽优先于来源兼容副本(两处分歧时读权威)', async () => {
    // 直接构造「权威槽 vs 来源副本」分歧的旧表:读路径必须取权威槽。
    memStorage.setItem(
      'xdt:providerModelMemory:v2',
      JSON.stringify({
        'claude-code:anthropic': {
          lastModel: 'claude-opus-4-8',
          effortByModel: { 'claude-opus-4-8': 'low' },
          fastByModel: {},
          thinkingByModel: {},
        },
        'claude-code:*': {
          lastModel: '',
          effortByModel: { 'claude-opus-4-8': 'max' },
          fastByModel: {},
          thinkingByModel: {},
        },
      }),
    );
    const m = await loadModule();
    expect(m.getProviderModelEffort('claude-code', 'anthropic', 'claude-opus-4-8')).toBe('max');
    expect(m.getProviderModelChoice('claude-code', 'anthropic')).toEqual({
      model: 'claude-opus-4-8',
      effort: 'max',
    });
    // 权威槽里没有的模型仍按来源副本兜底(旧数据只写过来源槽的情形)。
    // 换表后必须重置模块缓存,否则读到的是上一张表的进程内 snapshot。
    memStorage.setItem(
      'xdt:providerModelMemory:v2',
      JSON.stringify({
        'claude-code:xd': {
          lastModel: '',
          effortByModel: { 'gpt-5.5': 'xhigh' },
          fastByModel: {},
          thinkingByModel: {},
        },
      }),
    );
    vi.resetModules();
    const fallback = await loadModule();
    expect(fallback.getProviderModelEffort('claude-code', 'xd', 'gpt-5.5')).toBe('xhigh');
  });

  it('历史回填同时补齐 effort / fast / thinking 三个维度(逐个合并,不被链式短路漏掉)', async () => {
    memStorage.setItem(
      'xdt:providerModelMemory:v2',
      JSON.stringify({
        'pi:glm-coding-plan': {
          lastModel: 'glm-5.3-flash',
          effortByModel: { 'glm-5.3-flash': 'low' },
          fastByModel: { 'glm-5.3-flash': true },
          thinkingByModel: { 'glm-5.3-flash': false },
        },
      }),
    );
    const m = await loadModule();
    // 三个维度都必须进权威槽。写成 `merge(a) || merge(b) || merge(c)` 时,effort 一命中
    // 就短路,fastByModel / thinkingByModel 停在空 —— 与回填要消灭的「跨来源丢档位」同类。
    expect(m.snapshotForSeed()['pi:*']).toEqual({
      effortByModel: { 'glm-5.3-flash': 'low' },
      fastByModel: { 'glm-5.3-flash': true },
      thinkingByModel: { 'glm-5.3-flash': false },
    });
  });

  it('v2 历史数据(只有来源槽)首次读取即回填权威槽,不丢任何既有预设', async () => {
    // 这正是用户机器上的真实形状:`*` 槽从未被写过,偏好全在来源槽里。
    memStorage.setItem(
      'xdt:providerModelMemory:v2',
      JSON.stringify({
        'pi:glm-coding-plan': {
          lastModel: 'glm-5.3-flash',
          effortByModel: { 'glm-5.3-flash': 'low' },
          fastByModel: {},
          thinkingByModel: {},
        },
        'codex:openai': {
          lastModel: '',
          effortByModel: { 'gpt-5.5': 'max' },
          fastByModel: {},
          thinkingByModel: {},
        },
      }),
    );
    const m = await loadModule();
    // 读路径立即按「全局优先」看到回填值:换来源不再掉回默认档。
    expect(m.getProviderModelEffort('pi', 'zhipu-coding-plan-cn', 'glm-5.3-flash')).toBe('low');
    expect(m.getProviderModelEffort('codex', 'xd', 'gpt-5.5')).toBe('max');
    // 快照(镜像给 main / device-link 控制端)也带上权威槽。
    expect(m.snapshotForSeed()['pi:*']?.effortByModel).toEqual({ 'glm-5.3-flash': 'low' });
    expect(m.snapshotForSeed()['codex:*']?.effortByModel).toEqual({ 'gpt-5.5': 'max' });
    // 一次真实写入把回填结果带出内存,落盘后重启仍生效。
    m.setProviderModelEffort('pi', 'opencode-go', 'glm-5.3-flash', 'max');
    const persisted = JSON.parse(
      memStorage.getItem('xdt:providerModelMemory:v2') as string,
    ) as Record<string, { effortByModel: Record<string, string> }>;
    expect(persisted['pi:*'].effortByModel['glm-5.3-flash']).toBe('max');
  });

  it('来源槽已是目标值时,权威槽陈旧也要补写(双写不被半短路)', async () => {
    // 两处分歧:旧客户端只把来源槽写成 low,权威槽停在 medium(回填只补空缺不覆盖,
    // 这种不一致可以合法共存)。用户再次显式选 low 时必须把权威槽也带过来 ——
    // 只看来源槽就短路的话,其它来源仍被 medium 拽走。
    memStorage.setItem(
      'xdt:providerModelMemory:v2',
      JSON.stringify({
        'pi:glm-coding-plan': {
          lastModel: '',
          effortByModel: { 'glm-5.3-flash': 'low' },
          fastByModel: {},
          thinkingByModel: {},
        },
        'pi:*': {
          lastModel: '',
          effortByModel: { 'glm-5.3-flash': 'medium' },
          fastByModel: {},
          thinkingByModel: {},
        },
      }),
    );
    const m = await loadModule();
    m.setProviderModelEffort('pi', 'glm-coding-plan', 'glm-5.3-flash', 'low');
    expect(m.snapshotForSeed()['pi:*']?.effortByModel['glm-5.3-flash']).toBe('low');
    expect(m.snapshotForSeed()['pi:glm-coding-plan']?.effortByModel['glm-5.3-flash']).toBe('low');
  });

  it('snapshot 同时含权威槽与来源兼容副本', async () => {
    const m = await loadModule();
    m.setProviderModelEffort('claude-code', 'anthropic', 'claude-opus-4-8', 'xhigh');
    m.setProviderModelFast('claude-code', 'xd', 'claude-opus-4-8', true);
    expect(m.snapshotForSeed()['claude-code:anthropic']?.effortByModel).toEqual({
      'claude-opus-4-8': 'xhigh',
    });
    expect(m.snapshotForSeed()['claude-code:xd']?.fastByModel).toEqual({
      'claude-opus-4-8': true,
    });
    // 权威槽把两个来源写进来的值汇总(供 main / 控制端按「全局优先」读)。
    expect(m.snapshotForSeed()['claude-code:*']).toEqual({
      effortByModel: { 'claude-opus-4-8': 'xhigh' },
      fastByModel: { 'claude-opus-4-8': true },
      thinkingByModel: {},
    });
  });

  it('snapshot 带上思考开关', async () => {
    const m = await loadModule();
    m.setProviderModelThinking('pi', 'cindy-local-ollama', 'qwen3.8:27b-mxfp8', false);
    expect(m.snapshotForSeed()['pi:cindy-local-ollama']?.thinkingByModel).toEqual({
      'qwen3.8:27b-mxfp8': false,
    });
  });

  it('多模型 effort 跨重启持久化(v2)', async () => {
    const m1 = await loadModule();
    m1.setProviderModelChoice('claude-code', 'anthropic', 'claude-opus-4-8', 'high');
    m1.setProviderModelChoice('claude-code', 'anthropic', 'claude-haiku-4-5', 'low');
    vi.resetModules();
    const m2 = await loadModule();
    expect(m2.getProviderModelEffort('claude-code', 'anthropic', 'claude-opus-4-8')).toBe('high');
    expect(m2.getProviderModelEffort('claude-code', 'anthropic', 'claude-haiku-4-5')).toBe('low');
  });

  it('迁移历史 v1 单槽 → v2(lastModel + 该模型 effort 都可恢复)', async () => {
    memStorage.setItem(
      'xdt:providerModelMemory:v1',
      JSON.stringify({
        'claude-code:anthropic': { model: 'claude-opus-4-8', effort: 'xhigh' },
        'codex:openai': { model: 'gpt-5.5', effort: 'medium' },
      }),
    );
    vi.resetModules();
    const m = await loadModule();
    expect(m.getProviderModelChoice('claude-code', 'anthropic')).toEqual({
      model: 'claude-opus-4-8',
      effort: 'xhigh',
    });
    expect(m.getProviderModelEffort('claude-code', 'anthropic', 'claude-opus-4-8')).toBe('xhigh');
    expect(m.getProviderModelEffort('codex', 'openai', 'gpt-5.5')).toBe('medium');
  });

  it('v2 在场时忽略 v1(不回退迁移)', async () => {
    memStorage.setItem(
      'xdt:providerModelMemory:v2',
      JSON.stringify({
        'claude-code:anthropic': {
          lastModel: 'claude-opus-4-8',
          effortByModel: { 'claude-opus-4-8': 'high' },
        },
      }),
    );
    memStorage.setItem(
      'xdt:providerModelMemory:v1',
      JSON.stringify({ 'claude-code:anthropic': { model: 'claude-haiku-4-5', effort: 'low' } }),
    );
    vi.resetModules();
    const m = await loadModule();
    expect(m.getProviderModelChoice('claude-code', 'anthropic')).toEqual({
      model: 'claude-opus-4-8',
      effort: 'high',
    });
  });

  it('v2 脏数据:非法 effort 条目过滤 / 保留无深度模型的 lastModel / 缺 lastModel 仍可查 effort', async () => {
    memStorage.setItem(
      'xdt:providerModelMemory:v2',
      JSON.stringify({
        'claude-code:anthropic': {
          lastModel: 'claude-opus-4-8',
          effortByModel: { 'claude-opus-4-8': 'high', bad: 42 }, // bad 非 string → 过滤
        },
        'claude-code:xd': { lastModel: 'x', effortByModel: {} }, // 无 effort 仍保留 lastModel,choice 仍须有 effort
        'codex:openai': { effortByModel: { 'gpt-5.5': 'medium' } }, // 无 lastModel:effort 可查,choice undefined
      }),
    );
    vi.resetModules();
    const m = await loadModule();
    expect(m.getProviderModelEffort('claude-code', 'anthropic', 'claude-opus-4-8')).toBe('high');
    expect(m.getProviderModelEffort('claude-code', 'anthropic', 'bad')).toBeUndefined();
    expect(m.getProviderModelChoice('claude-code', 'xd')).toBeUndefined();
    expect(m.getProviderModelEffort('codex', 'openai', 'gpt-5.5')).toBe('medium');
    expect(m.getProviderModelChoice('codex', 'openai')).toBeUndefined();
  });
});

// ---------------------------------------------------------------------------
// fast 与 effort 同维度:per-(agent, model) 全局共享。providerId 只保留 capability / 旧 v2 回退用途。
// ---------------------------------------------------------------------------
describe('providerModelMemory —— (agent, model) fast 全局预设', () => {
  it('同一 model id 的 fast 跨来源共享(显式 false 也是有效值)', async () => {
    const m = await loadModule();
    m.setProviderModelFast('claude-code', 'anthropic', 'claude-opus-4-8', true);
    // fast 与 effort 同一口径:权威槽优先,来源副本同步。
    expect(m.getProviderModelFast('claude-code', 'xd', 'claude-opus-4-8')).toBe(true);
    m.setProviderModelFast('claude-code', 'xd', 'claude-opus-4-8', false);
    expect(m.getProviderModelFast('claude-code', 'anthropic', 'claude-opus-4-8')).toBe(false);
    expect(m.getProviderModelFast('claude-code', 'xd', 'claude-opus-4-8')).toBe(false);
  });

  it('fast 写入不动同槽 effort / lastModel;effort 写入不动 fast', async () => {
    const m = await loadModule();
    m.setProviderModelChoice('claude-code', 'anthropic', 'claude-opus-4-8', 'high');
    m.setProviderModelFast('claude-code', 'anthropic', 'claude-opus-4-8', true);
    // 两者并存,互不覆盖
    expect(m.getProviderModelEffort('claude-code', 'anthropic', 'claude-opus-4-8')).toBe('high');
    expect(m.getProviderModelFast('claude-code', 'anthropic', 'claude-opus-4-8')).toBe(true);
    // 再写 effort,fast 保持
    m.setProviderModelChoice('claude-code', 'anthropic', 'claude-opus-4-8', 'low');
    expect(m.getProviderModelFast('claude-code', 'anthropic', 'claude-opus-4-8')).toBe(true);
  });

  it('getProviderModelFast:未记录模型 / 空参 → undefined,显式 false 跨来源保留', async () => {
    const m = await loadModule();
    m.setProviderModelFast('claude-code', 'anthropic', 'claude-opus-4-8', false);
    expect(m.getProviderModelFast('claude-code', 'anthropic', 'claude-opus-4-8')).toBe(false);
    expect(m.getProviderModelFast('claude-code', 'anthropic', 'unknown-model')).toBeUndefined();
    // 显式 false 不因为是 false 就被当成「没记过」:另一个来源同样读到 false。
    expect(m.getProviderModelFast('claude-code', 'xd', 'claude-opus-4-8')).toBe(false);
    expect(m.getProviderModelFast('claude-code', '', 'claude-opus-4-8')).toBeUndefined();
    expect(m.getProviderModelFast('claude-code', 'anthropic', '')).toBeUndefined();
  });

  it('fast 跨重启持久化(v2)', async () => {
    const m1 = await loadModule();
    m1.setProviderModelFast('claude-code', 'anthropic', 'claude-opus-4-8', true);
    vi.resetModules();
    const m2 = await loadModule();
    expect(m2.getProviderModelFast('claude-code', 'anthropic', 'claude-opus-4-8')).toBe(true);
  });
});

// ---------------------------------------------------------------------------
// 「恢复推荐 / 回落默认」= **删记忆键**,不是把这一版的目录默认快照写回去
// (2026-08-17 review H3)。记忆表是 override 表:表里没有该键 ⇒ 跟随当前版本的默认。
// 写快照会把用户钉死在旧默认上 —— 服务端之后改了推荐档,点过「恢复推荐」的人吃不到。
// ---------------------------------------------------------------------------
describe('providerModelMemory —— clear:恢复推荐删键(不写默认快照)', () => {
  it('clearEffort 把全局槽与来源兼容副本两处一起删掉(只删一处会被另一处顶回来)', async () => {
    const m = await loadModule();
    m.setProviderModelChoice('claude-code', 'anthropic', 'claude-opus-4-8', 'high');
    expect(m.getProviderModelEffort('claude-code', 'anthropic', 'claude-opus-4-8')).toBe('high');

    m.clearProviderModelEffort('claude-code', 'anthropic', 'claude-opus-4-8');
    expect(m.getProviderModelEffort('claude-code', 'anthropic', 'claude-opus-4-8')).toBeUndefined();
    // 落盘里两个槽都不再有这个模型键 —— 留一份「等于当前默认」的快照就是把默认固化成用户配置。
    const persisted = JSON.parse(memStorage.getItem(m.__STORAGE_KEY) ?? '{}') as Record<
      string,
      { effortByModel: Record<string, string> }
    >;
    expect(persisted['claude-code:*']?.effortByModel['claude-opus-4-8']).toBeUndefined();
    expect(persisted['claude-code:anthropic']?.effortByModel['claude-opus-4-8']).toBeUndefined();

    // 重启后仍是「无记录 ⇒ 跟随目录默认」。
    vi.resetModules();
    const m2 = await loadModule();
    expect(
      m2.getProviderModelEffort('claude-code', 'anthropic', 'claude-opus-4-8'),
    ).toBeUndefined();
  });

  it('clearEffort 之后,别的来源留下的副本不会把旧值回填回权威槽', async () => {
    const m = await loadModule();
    // 同一模型在来源 A、B 各留一份预设(用户先后在两个来源上调过它)。
    m.setProviderModelChoice('claude-code', 'anthropic', 'claude-opus-4-8', 'low');
    m.setProviderModelChoice('claude-code', 'xd', 'claude-opus-4-8', 'high');
    // 从 A 点「恢复默认」= 删记忆键(跟随当前版本的目录默认)。
    m.clearProviderModelEffort('claude-code', 'anthropic', 'claude-opus-4-8');
    // B 的来源副本必须一起删:backfillGlobalPresets 只补空缺不覆盖,但只要 B 的副本还在,
    // 下一次 readMap 就会把它填回刚清空的权威槽 —— 用户的「恢复默认」被悄悄撤销。
    const persisted = JSON.parse(memStorage.getItem(m.__STORAGE_KEY) ?? '{}') as Record<
      string,
      { effortByModel: Record<string, string> }
    >;
    expect(persisted['claude-code:*']?.effortByModel['claude-opus-4-8']).toBeUndefined();
    expect(persisted['claude-code:anthropic']?.effortByModel['claude-opus-4-8']).toBeUndefined();
    expect(persisted['claude-code:xd']?.effortByModel['claude-opus-4-8']).toBeUndefined();
    // 重启后(重新走 readMap 回填)仍然没有记录 ⇒ 跟随目录默认。
    vi.resetModules();
    const m2 = await loadModule();
    expect(
      m2.getProviderModelEffort('claude-code', 'xd', 'claude-opus-4-8'),
    ).toBeUndefined();
    expect(m2.snapshotForSeed()['claude-code:*']?.effortByModel['claude-opus-4-8']).toBeUndefined();
  });

  it('全来源清除写盘失败后,另一窗口刚设的新值不被旧清除删掉', async () => {
    const m = await loadModule();
    m.setProviderModelMemoryOwner('owner-a');
    const ownerAKey = `${m.__STORAGE_KEY}:owner-a`;
    // 来源 A 与权威槽是 high,来源 B 是 low —— 形状取自 Greptile 的二审 finding。
    memStorage.setItem(
      ownerAKey,
      JSON.stringify({
        'claude-code:*': {
          lastModel: '',
          effortByModel: { 'claude-opus-4-8': 'high' },
          fastByModel: {},
          thinkingByModel: {},
        },
        'claude-code:anthropic': {
          lastModel: '',
          effortByModel: { 'claude-opus-4-8': 'high' },
          fastByModel: {},
          thinkingByModel: {},
        },
        'claude-code:xd': {
          lastModel: '',
          effortByModel: { 'claude-opus-4-8': 'low' },
          fastByModel: {},
          thinkingByModel: {},
        },
      }),
    );

    memStorage.setWritesFail(true);
    // 从 A 清除(会连带扫 B 的副本)—— 写盘失败,进 pending。
    m.clearProviderModelEffort('claude-code', 'anthropic', 'claude-opus-4-8');

    memStorage.setWritesFail(false);
    // 另一窗口把 B 显式设为 max(权威槽与 A 都仍是 high,所以只有 B 变了)。
    memStorage.setItem(
      ownerAKey,
      JSON.stringify({
        'claude-code:*': {
          lastModel: '',
          effortByModel: { 'claude-opus-4-8': 'high' },
          fastByModel: {},
          thinkingByModel: {},
        },
        'claude-code:anthropic': {
          lastModel: '',
          effortByModel: {},
          fastByModel: {},
          thinkingByModel: {},
        },
        'claude-code:xd': {
          lastModel: '',
          effortByModel: { 'claude-opus-4-8': 'max' },
          fastByModel: {},
          thinkingByModel: {},
        },
      }),
    );
    m.setProviderModelThinking('pi', 'xd', 'glm-5.3-flash', true);

    // 直接查落盘:B 的来源副本必须留着,权威槽也不该被陈旧重放改回去。
    // 不能只断言 getProviderModelEffort —— 读路径权威槽优先,B 被删也照样读到 high。
    const persisted = JSON.parse(memStorage.getItem(ownerAKey) ?? '{}') as Record<
      string,
      { effortByModel: Record<string, string> } | undefined
    >;
    expect(persisted['claude-code:xd']?.effortByModel['claude-opus-4-8']).toBe('max');
    expect(persisted['claude-code:*']?.effortByModel['claude-opus-4-8']).toBe('high');
    expect(persisted['claude-code:anthropic']?.effortByModel['claude-opus-4-8']).toBeUndefined();
  });

  it('clearFast 同理;删的是键而不是写一份显式 false', async () => {
    const m = await loadModule();
    m.setProviderModelFast('codex', 'xd', 'gpt-5.5', true);
    expect(m.getProviderModelFast('codex', 'xd', 'gpt-5.5')).toBe(true);
    m.clearProviderModelFast('codex', 'xd', 'gpt-5.5');
    // undefined(而不是 false):调用层按「缺省即关」解释,但不会被钉在这一版的默认上。
    expect(m.getProviderModelFast('codex', 'xd', 'gpt-5.5')).toBeUndefined();
    const persisted = JSON.parse(memStorage.getItem(m.__STORAGE_KEY) ?? '{}') as Record<
      string,
      { fastByModel: Record<string, boolean> }
    >;
    expect('gpt-5.5' in (persisted['codex:*']?.fastByModel ?? {})).toBe(false);
    expect('gpt-5.5' in (persisted['codex:xd']?.fastByModel ?? {})).toBe(false);
  });

  it('全来源清除写盘失败后,只有权威槽变化也让旧清除退休', async () => {
    const m = await loadModule();
    m.setProviderModelMemoryOwner('owner-a');
    const ownerAKey = `${m.__STORAGE_KEY}:owner-a`;
    // 权威槽 high,两个来源都是 low;清除失败后另一窗口写成「权威 high / 来源仍 low」——
    // 每个来源槽的值都没变,只有权威槽变。基线必须能发现它(clearedSlots 只扫来源副本,
    // 权威槽的变化只能靠 presetValue 这一项)。
    memStorage.setItem(
      ownerAKey,
      JSON.stringify({
        'claude-code:*': {
          lastModel: '',
          effortByModel: { 'claude-opus-4-8': 'high' },
          fastByModel: {},
          thinkingByModel: {},
        },
        'claude-code:anthropic': {
          lastModel: '',
          effortByModel: { 'claude-opus-4-8': 'low' },
          fastByModel: {},
          thinkingByModel: {},
        },
        'claude-code:xd': {
          lastModel: '',
          effortByModel: { 'claude-opus-4-8': 'low' },
          fastByModel: {},
          thinkingByModel: {},
        },
      }),
    );

    memStorage.setWritesFail(true);
    m.clearProviderModelEffort('claude-code', 'anthropic', 'claude-opus-4-8');

    memStorage.setWritesFail(false);
    // 权威槽仍是 high,但两个来源槽的值都没动 —— 只有权威槽这次真的被改过。
    memStorage.setItem(
      ownerAKey,
      JSON.stringify({
        'claude-code:*': {
          lastModel: '',
          effortByModel: { 'claude-opus-4-8': 'max' },
          fastByModel: {},
          thinkingByModel: {},
        },
        'claude-code:anthropic': {
          lastModel: '',
          effortByModel: { 'claude-opus-4-8': 'low' },
          fastByModel: {},
          thinkingByModel: {},
        },
        'claude-code:xd': {
          lastModel: '',
          effortByModel: { 'claude-opus-4-8': 'low' },
          fastByModel: {},
          thinkingByModel: {},
        },
      }),
    );
    m.setProviderModelThinking('pi', 'xd', 'glm-5.3-flash', true);

    const persisted = JSON.parse(memStorage.getItem(ownerAKey) ?? '{}') as Record<
      string,
      { effortByModel: Record<string, string> } | undefined
    >;
    expect(persisted['claude-code:*']?.effortByModel['claude-opus-4-8']).toBe('max');
    expect(persisted['claude-code:xd']?.effortByModel['claude-opus-4-8']).toBe('low');
  });

  it('clearFast 的写盘失败重放,同样不删别的来源刚设的新值', async () => {
    const m = await loadModule();
    m.setProviderModelMemoryOwner('owner-a');
    const ownerAKey = `${m.__STORAGE_KEY}:owner-a`;
    memStorage.setItem(
      ownerAKey,
      JSON.stringify({
        'codex:*': { lastModel: '', effortByModel: {}, fastByModel: { 'gpt-5.5': true }, thinkingByModel: {} },
        'codex:xd': { lastModel: '', effortByModel: {}, fastByModel: { 'gpt-5.5': true }, thinkingByModel: {} },
        'codex:openai': {
          lastModel: '',
          effortByModel: {},
          fastByModel: { 'gpt-5.5': false },
          thinkingByModel: {},
        },
      }),
    );

    memStorage.setWritesFail(true);
    m.clearProviderModelFast('codex', 'xd', 'gpt-5.5');

    memStorage.setWritesFail(false);
    // 另一窗口把 openai 显式设为 true(权威槽与 xd 都仍是 true,只有 openai 变了)。
    memStorage.setItem(
      ownerAKey,
      JSON.stringify({
        'codex:*': { lastModel: '', effortByModel: {}, fastByModel: { 'gpt-5.5': true }, thinkingByModel: {} },
        'codex:xd': { lastModel: '', effortByModel: {}, fastByModel: {}, thinkingByModel: {} },
        'codex:openai': {
          lastModel: '',
          effortByModel: {},
          fastByModel: { 'gpt-5.5': true },
          thinkingByModel: {},
        },
      }),
    );
    m.setProviderModelThinking('pi', 'xd', 'glm-5.3-flash', true);

    const persisted = JSON.parse(memStorage.getItem(ownerAKey) ?? '{}') as Record<
      string,
      { fastByModel: Record<string, boolean> } | undefined
    >;
    expect(persisted['codex:openai']?.fastByModel['gpt-5.5']).toBe(true);
  });

  it('clear 只删点名那个模型键,不动同槽其它模型 / 另一维 / lastModel', async () => {
    const m = await loadModule();
    m.setProviderModelChoice('codex', 'xd', 'gpt-5.5', 'high');
    m.setProviderModelEffort('codex', 'xd', 'deepseek-v4-pro', 'low');
    m.setProviderModelFast('codex', 'xd', 'gpt-5.5', true);

    m.clearProviderModelEffort('codex', 'xd', 'gpt-5.5');
    expect(m.getProviderModelEffort('codex', 'xd', 'gpt-5.5')).toBeUndefined();
    // 同槽另一个模型的深度、同模型的 Fast 都不受影响。
    expect(m.getProviderModelEffort('codex', 'xd', 'deepseek-v4-pro')).toBe('low');
    expect(m.getProviderModelFast('codex', 'xd', 'gpt-5.5')).toBe(true);
    // lastModel 仍在(切来源时的落点 hint 不该被「恢复推荐」顺手抹掉)。
    expect(m.getProviderModelChoice('codex', 'xd')).toBeUndefined(); // 该模型已无 effort
    m.setProviderModelEffort('codex', 'xd', 'gpt-5.5', 'low');
    expect(m.getProviderModelChoice('codex', 'xd')).toEqual({ model: 'gpt-5.5', effort: 'low' });
  });

  it('无记录 / 非法入参 → 静默短路,不落盘不通知', async () => {
    const m = await loadModule();
    const seen = vi.fn();
    m.subscribeProviderModelMemory(seen);
    m.clearProviderModelEffort('codex', 'xd', 'gpt-5.5');
    m.clearProviderModelFast('codex', 'xd', 'gpt-5.5');
    m.clearProviderModelEffort('codex', '', 'gpt-5.5');
    m.clearProviderModelEffort('codex', '*', 'gpt-5.5');
    m.clearProviderModelFast('codex', 'xd', '');
    expect(seen).not.toHaveBeenCalled();
    expect(memStorage.getItem(m.__STORAGE_KEY)).toBeNull();
  });
});


it('last-model-only history is evidence of an existing user configuration', async () => {
  memStorage.setItem('xdt:providerModelMemory:v2', JSON.stringify({
    'codex:xd': { lastModel: 'old-model', effortByModel: {} },
  }));
  vi.resetModules();
  const memory = await loadModule();
  expect(memory.hasProviderModelHistory()).toBe(true);
  expect(memory.hasAnyProviderModelOverride()).toBe(false);
});

it('does not stamp previous-owner model tuning during the auth handoff', async () => {
  const memory = await loadModule();
  memory.setProviderModelMemoryOwner('A');
  memory.setProviderModelEffort('codex', 'provider', 'target', 'low');
  expect(memory.snapshotForSeed('A')?.['codex:provider'].effortByModel.target).toBe('low');
  expect(memory.snapshotForSeed('B')).toBeNull();
  memory.setProviderModelMemoryOwner('B');
  expect(memory.snapshotForSeed('B')).toEqual({});
  expect(memory.snapshotForSeed('A')).toBeNull();
});