Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
/**
* 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();
});