Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import type { Message } from '@/lib/ccAgent.types';
vi.mock('@/lib/messageService', () => ({
list: vi.fn(async () => []),
around: vi.fn(async () => []),
create: vi.fn(async () => ({}) as unknown),
updateContent: vi.fn(async () => ({}) as unknown),
}));
vi.mock('@/lib/sessionService', () => ({
get: vi.fn(async () => ({
agentKind: 'cc',
remoteHostId: null,
sdkSessionId: null,
fastMode: false,
contextTokens: 0,
contextWindow: 0,
totalCostUsd: 0,
})),
update: vi.fn(async () => ({})),
touchUserSend: vi.fn(async () => ({})),
}));
vi.mock('@/lib/sessionsBus', () => ({
emitPatch: vi.fn(),
}));
vi.mock('@/lib/userPromptStore', () => ({
getUserPrompt: () => '',
}));
vi.mock('@/lib/imageRef', () => ({
parseUserContent: vi.fn((c: string) => ({ text: c, images: [], files: [] })),
stringifyUserContent: vi.fn((text: string) => text),
}));
vi.mock('@/lib/composerDraftStore', () => ({
saveDraft: vi.fn(),
setRemoteOptimisticAttachmentUrls: vi.fn(),
plainTextToTiptapDoc: (s: string) => ({
type: 'doc',
content: [{ type: 'paragraph', content: [{ type: 'text', text: s }] }],
}),
}));
import { makerChatStore } from '@/lib/makerChatStore';
import * as messageService from '@/lib/messageService';
import * as sessionService from '@/lib/sessionService';
import {
markSessionAutomaticHistoryLoadCompleted,
restoreSessionAutomaticHistoryLoadAttempts,
saveSessionScroll,
clearSessionScroll,
} from '@/lib/sessionScrollStore';
const BASE_TIME = new Date('2026-05-20T00:00:00.000Z');
let disposers: Array<() => void> = [];
let sessionIds: string[] = [];
function sid(label: string): string {
const value = `${label}-${Math.random().toString(36).slice(2, 8)}`;
sessionIds.push(value);
return value;
}
function enter(sessionId: string): () => void {
const dispose = makerChatStore.enterView(sessionId);
disposers.push(dispose);
return dispose;
}
function addMessage(sessionId: string): void {
makerChatStore.insertSystemCard(sessionId, 'status', { label: sessionId });
}
async function flushPromises(rounds = 6): Promise<void> {
for (let i = 0; i < rounds; i += 1) await Promise.resolve();
}
function dbMessage(
sessionId: string,
id: string,
content: string,
createdAt: string,
clientId = `client-${id}`,
): Message {
return {
id,
clientId,
sessionId,
role: 'assistant',
content,
toolUseId: null,
agentMeta: null,
createdAt,
};
}
function dbToolUseMessage(
sessionId: string,
id: string,
toolName: string,
input: unknown,
createdAt: string,
): Message {
const toolUseId = `tool-${id}`;
return {
id,
clientId: `client-${id}`,
sessionId,
role: 'tool_use',
content: { toolName, input, toolUseId },
toolUseId,
agentMeta: null,
createdAt,
} as unknown as Message;
}
function dbToolResultMessage(
sessionId: string,
id: string,
toolUseId: string,
content: string,
createdAt: string,
): Message {
return {
id,
clientId: `client-${id}`,
sessionId,
role: 'tool_result',
content,
toolUseId,
agentMeta: null,
createdAt,
} as unknown as Message;
}
function thinkingDbMessage(
sessionId: string,
id: string,
text: string,
createdAt: string,
durationMs: number,
opts: { finishedAt?: number } = {},
): Message {
return {
id,
clientId: `client-${id}`,
sessionId,
role: 'thinking',
content: { kind: 'thinking', text, durationMs, isRedacted: false, ...opts },
toolUseId: null,
agentMeta: null,
createdAt,
};
}
describe('makerChatStore active view tracking', () => {
beforeEach(() => {
vi.useFakeTimers();
vi.setSystemTime(BASE_TIME);
vi.mocked(messageService.list).mockReset();
vi.mocked(messageService.list).mockResolvedValue([]);
vi.mocked(messageService.around).mockReset();
vi.mocked(messageService.around).mockResolvedValue([]);
disposers = [];
sessionIds = [];
});
afterEach(() => {
for (const dispose of [...disposers].reverse()) dispose();
for (const sessionId of sessionIds) {
makerChatStore.purgeSession(sessionId);
clearSessionScroll(sessionId);
}
makerChatStore.__teardownGlobalListeners();
vi.unstubAllGlobals();
vi.useRealTimers();
});
async function readingWindow(label: string, count = 350, contentSize = 1) {
const id = sid(label);
const leave = enter(id);
vi.mocked(messageService.list).mockResolvedValueOnce(Array.from({ length: count }, (_, i) =>
dbMessage(id, `${i}`, 'x'.repeat(contentSize), new Date(BASE_TIME.getTime() + i * 1000).toISOString()),
));
makerChatStore.ensureInitialMessages(id);
await flushPromises();
saveSessionScroll(id, { windowAnchorKey: null, viewportTopKey: 'msg-client-0',
messageClientId: 'client-0', offset: 0, isNearBottom: false });
return { id, leave, messages: makerChatStore.getSnapshot(id).messages };
}
it('keeps a bounded old reading window on a hot return without another history read', async () => {
const view = await readingWindow('reading');
view.leave();
expect(makerChatStore.getSnapshot(view.id).messages).toBe(view.messages);
enter(view.id);
makerChatStore.ensureInitialMessages(view.id);
await flushPromises();
expect(makerChatStore.getSnapshot(view.id).messages).toBe(view.messages);
expect(messageService.list).toHaveBeenCalledTimes(1);
});
it('cannot resurrect a retained reading window after purge and same-id reopen', async () => {
const view = await readingWindow('purged-reading');
view.leave();
makerChatStore.purgeSession(view.id);
vi.mocked(messageService.list).mockResolvedValueOnce([
dbMessage(view.id, 'fresh', 'new history', BASE_TIME.toISOString()),
]);
enter(view.id);
makerChatStore.ensureInitialMessages(view.id);
await flushPromises();
expect(makerChatStore.getSnapshot(view.id).messages.map((message) => message.clientId))
.toEqual(['client-fresh']);
});
it('trims the displaced third reading window immediately and respects final-view ownership', async () => {
const a = await readingWindow('reading-a');
const extra = enter(a.id);
a.leave();
expect(makerChatStore.getSnapshot(a.id).messages).toBe(a.messages);
extra();
const b = await readingWindow('reading-b'); b.leave();
const c = await readingWindow('reading-c'); c.leave();
expect(makerChatStore.getSnapshot(a.id).messages).toHaveLength(200);
expect(makerChatStore.getSnapshot(b.id).messages).toBe(b.messages);
expect(makerChatStore.getSnapshot(c.id).messages).toBe(c.messages);
});
it('does not reserve tail views, oversized row counts or oversized text windows', async () => {
const tail = await readingWindow('tail');
saveSessionScroll(tail.id, { windowAnchorKey: null, viewportTopKey: 'msg-client-0', offset: 0, isNearBottom: true });
tail.leave();
expect(makerChatStore.getSnapshot(tail.id).messages).toHaveLength(200);
const many = await readingWindow('many', 1001); many.leave();
expect(makerChatStore.getSnapshot(many.id).messages).toHaveLength(200);
const large = await readingWindow('large', 350, 100_000); large.leave();
expect(makerChatStore.getSnapshot(large.id).messages).toHaveLength(200);
});
it('bounds the combined text budget and keeps retained histories past five minutes', async () => {
const a = await readingWindow('budget-a', 350, 50_000); a.leave();
const b = await readingWindow('budget-b', 350, 50_000); b.leave();
expect(makerChatStore.getSnapshot(a.id).messages).toHaveLength(200);
expect(makerChatStore.getSnapshot(b.id).messages).toBe(b.messages);
vi.advanceTimersByTime(10 * 60_000);
expect(makerChatStore.getSnapshot(b.id).messages).toBe(b.messages);
});
it('enterView marks a session active and clears lastViewedAt', () => {
const sessionId = sid('enter');
const dispose = enter(sessionId);
dispose();
vi.setSystemTime(new Date(BASE_TIME.getTime() + 1_000));
const disposeAgain = enter(sessionId);
expect(makerChatStore.__activeViewTest.getActiveSessionIds()).toContain(sessionId);
expect(makerChatStore.__activeViewTest.getLastViewedAt(sessionId)).toBeUndefined();
disposeAgain();
});
it('leaveView removes a session and records lastViewedAt', () => {
const sessionId = sid('leave');
const dispose = enter(sessionId);
vi.setSystemTime(new Date(BASE_TIME.getTime() + 2_000));
dispose();
expect(makerChatStore.__activeViewTest.getActiveSessionIds()).not.toContain(sessionId);
expect(makerChatStore.__activeViewTest.getLastViewedAt(sessionId)).toBe(BASE_TIME.getTime() + 2_000);
});
it('keeps two simultaneously mounted Orca panes out of soft eviction', () => {
const leadId = sid('lead');
const workerId = sid('worker');
const disposeLead = enter(leadId);
const disposeWorker = enter(workerId);
addMessage(leadId);
addMessage(workerId);
vi.advanceTimersByTime(90_000);
expect(makerChatStore.getSnapshot(leadId).messages).toHaveLength(1);
expect(makerChatStore.getSnapshot(workerId).messages).toHaveLength(1);
disposeWorker();
disposeLead();
});
// F3 回归:硬 LRU 回收 (_evictLruIfNeeded,缓存 > MAX_CACHED_SESSIONS 时触发) 必须
// 跳过仍被 mounted view 看着的 session —— 多窗/分屏副屏钉的 idle 会话不能因为沉到
// LRU 最旧就被 _purgeSession 删掉(否则活 view 变 blank)。与 demote/trim 对齐。
it('never hard-evicts an active-view session even when it is the LRU-oldest', () => {
// keepId 先建 + 落一条消息(此刻在 MRU),随后不再 touch → 被后续创建挤到 LRU 最旧。
const keepId = sid('keep-active');
addMessage(keepId);
enter(keepId); // 标记为 active-view(模拟副窗钉着它)
// 创建 25 个(> MAX_CACHED_SESSIONS=20)idle 会话,反复强制触发硬回收。
const otherIds: string[] = [];
for (let i = 0; i < 25; i++) {
const id = sid(`idle-${i}`);
otherIds.push(id);
addMessage(id);
}
// keepId 虽是 LRU 最旧,但 active-view → 不被回收,消息仍在。
expect(makerChatStore.getSnapshot(keepId).messages).toHaveLength(1);
// 非空泛验证:回收确实发生了 —— 最早创建的 idle 会话(非 active)已被 purge,
// 重新 getSnapshot 只会拿到重建的空 slice。
expect(makerChatStore.getSnapshot(otherIds[0]).messages).toHaveLength(0);
});
it.each([0, 9_000])('keeps read-projected windows replaceable unless history has %s used tokens', async (contextTokens) => {
const sessionId = sid('projected-context');
vi.mocked(sessionService.get).mockResolvedValueOnce({
agentKind: 'cc', remoteHostId: null, sdkSessionId: null, fastMode: false,
contextTokens, contextWindow: 272_000, totalCostUsd: 0,
} as Awaited<ReturnType<typeof sessionService.get>>);
makerChatStore.ensureInitialMessages(sessionId);
await flushPromises();
expect(makerChatStore.getSnapshot(sessionId).agentStatus.contextWindow).toBe(272_000);
makerChatStore.setContextWindow(sessionId, 1_000_000);
expect(makerChatStore.getSnapshot(sessionId).agentStatus.contextWindow)
.toBe(contextTokens > 0 ? 272_000 : 1_000_000);
});
it('initial history load backfills to the latest plan boundary', async () => {
const sessionId = sid('initial-plan-backfill');
const latestPage = Array.from({ length: 49 }, (_, i) =>
dbMessage(
sessionId,
`latest-${String(i).padStart(2, '0')}`,
`latest message ${i}`,
new Date(BASE_TIME.getTime() + (60 + i) * 1000).toISOString(),
),
);
const latestPlan = dbToolUseMessage(
sessionId,
'latest-plan',
'TaskUpdate',
{ taskId: 'abc', status: 'completed' },
new Date(BASE_TIME.getTime() + 120_000).toISOString(),
);
const olderPlan = dbToolUseMessage(
sessionId,
'older-plan',
'update_plan',
{ plan: [{ step: 'Older unresolved source', status: 'completed' }] },
new Date(BASE_TIME.getTime() + 30_000).toISOString(),
);
vi.mocked(messageService.list)
.mockResolvedValueOnce([...latestPage, latestPlan])
.mockResolvedValueOnce([olderPlan]);
makerChatStore.ensureInitialMessages(sessionId);
await flushPromises();
const snapshot = makerChatStore.getSnapshot(sessionId);
expect(messageService.list).toHaveBeenNthCalledWith(1, sessionId, undefined);
expect(messageService.list).toHaveBeenNthCalledWith(2, sessionId, {
limit: 50,
before: 'latest-00',
});
expect(snapshot.messages.some((message) => message.toolName === 'update_plan')).toBe(true);
expect(snapshot.oldestMessageId).toBe('older-plan');
});
it('shows the latest page before background plan discovery completes', async () => {
const sessionId = sid('initial-page-first');
const latestPage = Array.from({ length: 49 }, (_, i) =>
dbMessage(
sessionId,
`latest-${String(i).padStart(2, '0')}`,
`latest message ${i}`,
new Date(BASE_TIME.getTime() + (60 + i) * 1000).toISOString(),
),
);
const latestPlan = dbToolUseMessage(
sessionId,
'latest-plan',
'TaskUpdate',
{ taskId: 'abc', status: 'completed' },
new Date(BASE_TIME.getTime() + 120_000).toISOString(),
);
let resolveOlderPage!: (rows: Message[]) => void;
vi.mocked(messageService.list)
.mockResolvedValueOnce([...latestPage, latestPlan])
.mockReturnValueOnce(
new Promise<Message[]>((resolve) => {
resolveOlderPage = resolve;
}),
);
makerChatStore.ensureInitialMessages(sessionId);
await flushPromises(4);
const firstPageSnapshot = makerChatStore.getSnapshot(sessionId);
expect(firstPageSnapshot.messages).toHaveLength(50);
expect(firstPageSnapshot.historyLoaded).toBe(false);
expect(firstPageSnapshot.isLoadingMore).toBe(true);
expect(messageService.list).toHaveBeenCalledTimes(2);
// The background phase owns the same pagination lock; a user scroll cannot
// start a competing request or move the cursor backwards.
makerChatStore.loadOlderMessages(sessionId);
expect(messageService.list).toHaveBeenCalledTimes(2);
const olderPage = [
dbMessage(sessionId, 'older-visible', 'older visible message', BASE_TIME.toISOString()),
];
resolveOlderPage(olderPage);
await flushPromises();
const finalSnapshot = makerChatStore.getSnapshot(sessionId);
expect(finalSnapshot.messages.some((message) => message.clientId === 'client-older-visible')).toBe(true);
expect(finalSnapshot.historyLoaded).toBe(true);
expect(finalSnapshot.isLoadingMore).toBe(false);
});
it('initial history load treats swallowed plan tool rows as non-anchor rows', async () => {
const sessionId = sid('initial-plan-non-anchor');
// Preserve a local-only row so loadOlderMessages would have a beforeTs
// cursor if the initial non-anchor backfill failed to acquire its lock.
addMessage(sessionId);
vi.mocked(messageService.list).mockClear();
const latestPage = Array.from({ length: 50 }, (_, i) =>
dbToolUseMessage(
sessionId,
`plan-${String(i).padStart(2, '0')}`,
'update_plan',
{ plan: [{ step: `Plan row ${i}`, status: 'completed' }] },
new Date(BASE_TIME.getTime() + (60 + i) * 1000).toISOString(),
),
);
let resolveOlderPage!: (rows: Message[]) => void;
vi.mocked(messageService.list)
.mockResolvedValueOnce(latestPage)
.mockReturnValueOnce(
new Promise<Message[]>((resolve) => {
resolveOlderPage = resolve;
}),
);
makerChatStore.ensureInitialMessages(sessionId);
await flushPromises(4);
expect(messageService.list).toHaveBeenCalledTimes(2);
expect(messageService.list).toHaveBeenNthCalledWith(2, sessionId, {
limit: 50,
before: 'plan-00',
});
expect(makerChatStore.getSnapshot(sessionId).isLoadingMore).toBe(true);
makerChatStore.loadOlderMessages(sessionId);
expect(messageService.list).toHaveBeenCalledTimes(2);
resolveOlderPage([
dbMessage(sessionId, 'older-visible', 'older visible message', BASE_TIME.toISOString()),
]);
await flushPromises();
const snapshot = makerChatStore.getSnapshot(sessionId);
expect(snapshot.oldestMessageId).toBe('older-visible');
expect(snapshot.historyLoaded).toBe(true);
expect(snapshot.isLoadingMore).toBe(false);
});
it('does not page through filler history on open just to find a later plan', async () => {
const sessionId = sid('initial-plan-backfill-deep');
vi.mocked(messageService.list).mockClear();
const page = (prefix: string, startOffsetSeconds: number) =>
Array.from({ length: 50 }, (_, i) =>
dbMessage(
sessionId,
`${prefix}-${String(i).padStart(2, '0')}`,
`${prefix} message ${i}`,
new Date(BASE_TIME.getTime() + (startOffsetSeconds + i) * 1000).toISOString(),
),
);
vi.mocked(messageService.list)
.mockResolvedValueOnce(page('latest', 300))
.mockResolvedValueOnce(page('older-1', 200))
.mockResolvedValueOnce(page('older-2', 100))
.mockResolvedValueOnce(page('older-3', 0))
.mockResolvedValueOnce([
dbToolUseMessage(
sessionId,
'older-plan',
'update_plan',
{ plan: [{ step: 'Deep plan boundary', status: 'in_progress' }] },
new Date(BASE_TIME.getTime() - 100_000).toISOString(),
),
]);
makerChatStore.ensureInitialMessages(sessionId);
await flushPromises();
expect(messageService.list).toHaveBeenCalledTimes(1);
expect(makerChatStore.getSnapshot(sessionId).oldestMessageId).toBe('latest-00');
expect(makerChatStore.getSnapshot(sessionId).historyLoaded).toBe(true);
});
it('does not probe older pages on open for sessions that never used plans', async () => {
const sessionId = sid('initial-plan-backfill-no-plan');
vi.mocked(messageService.list).mockClear();
const page = (prefix: string, startOffsetSeconds: number) =>
Array.from({ length: 50 }, (_, i) =>
dbMessage(
sessionId,
`${prefix}-${String(i).padStart(2, '0')}`,
`${prefix} message ${i}`,
new Date(BASE_TIME.getTime() + (startOffsetSeconds + i) * 1000).toISOString(),
),
);
vi.mocked(messageService.list)
.mockResolvedValueOnce(page('latest', 1000));
for (let i = 0; i < 12; i += 1) {
vi.mocked(messageService.list).mockResolvedValueOnce(page(`older-${i}`, 900 - i * 100));
}
makerChatStore.ensureInitialMessages(sessionId);
await flushPromises(20);
expect(messageService.list).toHaveBeenCalledTimes(1);
expect(makerChatStore.getSnapshot(sessionId).oldestMessageId).toBe('latest-00');
expect(makerChatStore.getSnapshot(sessionId).historyLoaded).toBe(true);
});
it('loads one older page after idle when the newest page has no plan', async () => {
const sessionId = sid('idle-plan-discovery');
enter(sessionId);
vi.mocked(messageService.list).mockClear();
const latest = Array.from({ length: 50 }, (_, i) =>
dbMessage(
sessionId,
`latest-${String(i).padStart(2, '0')}`,
`latest message ${i}`,
new Date(BASE_TIME.getTime() + (1000 + i) * 1000).toISOString(),
),
);
const olderPlan = [
dbToolUseMessage(
sessionId,
'idle-plan',
'update_plan',
{ plan: [{ step: 'Idle discovered plan', status: 'in_progress' }] },
new Date(BASE_TIME.getTime() - 1_000).toISOString(),
),
];
vi.mocked(messageService.list)
.mockResolvedValueOnce(latest)
.mockResolvedValueOnce(olderPlan);
makerChatStore.ensureInitialMessages(sessionId);
await flushPromises(20);
expect(messageService.list).toHaveBeenCalledTimes(1);
await vi.advanceTimersByTimeAsync(200);
await flushPromises(20);
expect(messageService.list).toHaveBeenCalledTimes(2);
expect(messageService.list).toHaveBeenNthCalledWith(2, sessionId, {
limit: 50,
before: 'latest-00',
});
expect(makerChatStore.getSnapshot(sessionId).oldestMessageId).toBe('idle-plan');
expect(restoreSessionAutomaticHistoryLoadAttempts(sessionId, 5)).toBe(0);
});
it('continues idle discovery into plan resolution when the extra page is unresolved', async () => {
const sessionId = sid('idle-plan-resolution');
enter(sessionId);
vi.mocked(messageService.list).mockClear();
const latest = Array.from({ length: 50 }, (_, i) =>
dbMessage(
sessionId,
`latest-${String(i).padStart(2, '0')}`,
`latest message ${i}`,
new Date(BASE_TIME.getTime() + (2000 + i) * 1000).toISOString(),
),
);
const unresolvedPage = [
...Array.from({ length: 49 }, (_, i) =>
dbMessage(
sessionId,
`mid-${String(i).padStart(2, '0')}`,
`mid message ${i}`,
new Date(BASE_TIME.getTime() + (1000 + i) * 1000).toISOString(),
),
),
dbToolUseMessage(
sessionId,
'latest-task-update',
'TaskUpdate',
{ taskId: 'abc', status: 'completed' },
new Date(BASE_TIME.getTime() + 1_500_000).toISOString(),
),
];
const resolvedPage = [
dbToolUseMessage(
sessionId,
'task-create',
'TaskCreate',
{ subject: 'Collect logs' },
new Date(BASE_TIME.getTime() - 2_000).toISOString(),
),
dbToolResultMessage(
sessionId,
'task-create-result',
'tool-task-create',
'Task #abc created successfully: Collect logs',
new Date(BASE_TIME.getTime() - 1_000).toISOString(),
),
];
vi.mocked(messageService.list)
.mockResolvedValueOnce(latest)
.mockResolvedValueOnce(unresolvedPage)
.mockResolvedValueOnce(resolvedPage);
makerChatStore.ensureInitialMessages(sessionId);
await flushPromises(20);
expect(messageService.list).toHaveBeenCalledTimes(1);
await vi.advanceTimersByTimeAsync(200);
await flushPromises(20);
expect(messageService.list).toHaveBeenCalledTimes(3);
expect(makerChatStore.getSnapshot(sessionId).oldestMessageId).toBe('task-create');
});
it('schedules idle plan discovery when a prefetched session later mounts', async () => {
const sessionId = sid('prefetch-then-enter');
vi.mocked(messageService.list).mockClear();
const latest = Array.from({ length: 50 }, (_, i) =>
dbMessage(
sessionId,
`latest-${String(i).padStart(2, '0')}`,
`latest message ${i}`,
new Date(BASE_TIME.getTime() + (1000 + i) * 1000).toISOString(),
),
);
const olderPlan = [
dbToolUseMessage(
sessionId,
'prefetch-plan',
'update_plan',
{ plan: [{ step: 'Prefetch discovered plan', status: 'in_progress' }] },
new Date(BASE_TIME.getTime() - 1_000).toISOString(),
),
];
vi.mocked(messageService.list)
.mockResolvedValueOnce(latest)
.mockResolvedValueOnce(olderPlan);
makerChatStore.ensureInitialMessages(sessionId);
await flushPromises(20);
expect(messageService.list).toHaveBeenCalledTimes(1);
await vi.advanceTimersByTimeAsync(200);
await flushPromises(20);
expect(messageService.list).toHaveBeenCalledTimes(1);
enter(sessionId);
await vi.advanceTimersByTimeAsync(200);
await flushPromises(20);
expect(messageService.list).toHaveBeenCalledTimes(2);
expect(makerChatStore.getSnapshot(sessionId).oldestMessageId).toBe('prefetch-plan');
});
it('continues initial plan backfill past older sources until a latest TaskUpdate can be resolved', async () => {
const sessionId = sid('initial-plan-task-boundary');
vi.mocked(messageService.list).mockClear();
const fillerPage = (prefix: string, startOffsetSeconds: number) =>
Array.from({ length: 49 }, (_, i) =>
dbMessage(
sessionId,
`${prefix}-${String(i).padStart(2, '0')}`,
`${prefix} message ${i}`,
new Date(BASE_TIME.getTime() + (startOffsetSeconds + i) * 1000).toISOString(),
),
);
const latestTaskUpdate = dbToolUseMessage(
sessionId,
'latest-task-update',
'TaskUpdate',
{ taskId: 'abc', status: 'completed' },
new Date(BASE_TIME.getTime() + 3_000_000).toISOString(),
);
const olderTodo = dbToolUseMessage(
sessionId,
'older-todo',
'TodoWrite',
{ todos: [{ content: 'Older source should not stop backfill', status: 'in_progress' }] },
new Date(BASE_TIME.getTime() + 1_100_000).toISOString(),
);
const taskCreate = dbToolUseMessage(
sessionId,
'task-create',
'TaskCreate',
{ subject: 'Collect logs' },
new Date(BASE_TIME.getTime() - 2_000).toISOString(),
);
const taskCreateResult = dbToolResultMessage(
sessionId,
'task-create-result',
'tool-task-create',
'Task #abc created successfully: Collect logs',
new Date(BASE_TIME.getTime() - 1_000).toISOString(),
);
vi.mocked(messageService.list)
.mockResolvedValueOnce([...fillerPage('latest', 2000), latestTaskUpdate])
.mockResolvedValueOnce([...fillerPage('older-1', 1000), olderTodo])
.mockResolvedValueOnce([taskCreate, taskCreateResult]);
makerChatStore.ensureInitialMessages(sessionId);
await flushPromises(10);
expect(messageService.list).toHaveBeenCalledTimes(3);
expect(messageService.list).toHaveBeenNthCalledWith(3, sessionId, {
limit: 50,
before: 'older-1-00',
});
expect(makerChatStore.getSnapshot(sessionId).oldestMessageId).toBe('task-create');
});
it('continues plan backfill when the visible TaskCreate may be a later step in the same plan', async () => {
const sessionId = sid('initial-plan-missing-earlier-create');
vi.mocked(messageService.list).mockClear();
const filler = Array.from({ length: 47 }, (_, i) =>
dbMessage(
sessionId,
`latest-${String(i).padStart(2, '0')}`,
`latest message ${i}`,
new Date(BASE_TIME.getTime() + (100 + i) * 1000).toISOString(),
),
);
const laterCreate = dbToolUseMessage(
sessionId,
'later-task-create',
'TaskCreate',
{ subject: 'Fix renderer' },
new Date(BASE_TIME.getTime() + 200_000).toISOString(),
);
const laterResult = dbToolResultMessage(
sessionId,
'later-task-result',
'tool-later-task-create',
'Task #2 created successfully: Fix renderer',
new Date(BASE_TIME.getTime() + 201_000).toISOString(),
);
const laterUpdate = dbToolUseMessage(
sessionId,
'later-task-update',
'TaskUpdate',
{ taskId: '2', status: 'in_progress' },
new Date(BASE_TIME.getTime() + 202_000).toISOString(),
);
const earlierCreate = dbToolUseMessage(
sessionId,
'earlier-task-create',
'TaskCreate',
{ subject: 'Inspect logs' },
new Date(BASE_TIME.getTime() - 2_000).toISOString(),
);
const earlierResult = dbToolResultMessage(
sessionId,
'earlier-task-result',
'tool-earlier-task-create',
'Task #1 created successfully: Inspect logs',
new Date(BASE_TIME.getTime() - 1_000).toISOString(),
);
vi.mocked(messageService.list)
.mockResolvedValueOnce([...filler, laterCreate, laterResult, laterUpdate])
.mockResolvedValueOnce([earlierCreate, earlierResult]);
makerChatStore.ensureInitialMessages(sessionId);
await flushPromises(10);
expect(messageService.list).toHaveBeenCalledTimes(2);
expect(messageService.list).toHaveBeenNthCalledWith(2, sessionId, {
limit: 50,
before: 'latest-00',
});
expect(makerChatStore.getSnapshot(sessionId).oldestMessageId).toBe('earlier-task-create');
});
it('continues plan backfill past an unrelated visible task until the updated task is found', async () => {
const sessionId = sid('initial-plan-unrelated-task');
vi.mocked(messageService.list).mockClear();
const fillerPage = (prefix: string, startOffsetSeconds: number, count = 49) =>
Array.from({ length: count }, (_, i) =>
dbMessage(
sessionId,
`${prefix}-${String(i).padStart(2, '0')}`,
`${prefix} message ${i}`,
new Date(BASE_TIME.getTime() + (startOffsetSeconds + i) * 1000).toISOString(),
),
);
const latestTaskUpdate = dbToolUseMessage(
sessionId,
'latest-task-update',
'TaskUpdate',
{ taskId: 'abc', status: 'completed' },
new Date(BASE_TIME.getTime() + 3_000_000).toISOString(),
);
const unrelatedCreate = dbToolUseMessage(
sessionId,
'unrelated-task-create',
'TaskCreate',
{ subject: 'Fix existing tests' },
new Date(BASE_TIME.getTime() + 1_100_000).toISOString(),
);
const unrelatedResult = dbToolResultMessage(
sessionId,
'unrelated-task-result',
'tool-unrelated-task-create',
'Task #def created successfully: Fix existing tests',
new Date(BASE_TIME.getTime() + 1_100_001).toISOString(),
);
const targetCreate = dbToolUseMessage(
sessionId,
'target-task-create',
'TaskCreate',
{ subject: 'Run stress tests' },
new Date(BASE_TIME.getTime() - 4_000).toISOString(),
);
const targetResult = dbToolResultMessage(
sessionId,
'target-task-result',
'tool-target-task-create',
'Task #abc created successfully: Run stress tests',
new Date(BASE_TIME.getTime() - 3_000).toISOString(),
);
const missingOlderUpdate = dbToolUseMessage(
sessionId,
'missing-task-update',
'TaskUpdate',
{ taskId: 'legacy', status: 'completed' },
new Date(BASE_TIME.getTime() - 2_000).toISOString(),
);
const missingOlderCreate = dbToolUseMessage(
sessionId,
'missing-task-create',
'TaskCreate',
{ subject: 'Inspect collision failures' },
new Date(BASE_TIME.getTime() - 6_000).toISOString(),
);
const missingOlderResult = dbToolResultMessage(
sessionId,
'missing-task-result',
'tool-missing-task-create',
'Task #legacy created successfully: Inspect collision failures',
new Date(BASE_TIME.getTime() - 5_000).toISOString(),
);
vi.mocked(messageService.list)
.mockResolvedValueOnce([...fillerPage('latest', 2000), latestTaskUpdate])
.mockResolvedValueOnce([
...fillerPage('middle', 1000, 48),
unrelatedCreate,
unrelatedResult,
])
.mockResolvedValueOnce([
...fillerPage('older-target', 100, 47),
targetCreate,
targetResult,
missingOlderUpdate,
])
.mockResolvedValueOnce([missingOlderCreate, missingOlderResult]);
makerChatStore.ensureInitialMessages(sessionId);
await flushPromises(10);
expect(messageService.list).toHaveBeenCalledTimes(4);
expect(messageService.list).toHaveBeenNthCalledWith(4, sessionId, {
limit: 50,
before: 'target-task-create',
});
expect(makerChatStore.getSnapshot(sessionId).oldestMessageId).toBe('missing-task-create');
});
it('caps initial plan resolution backfill when a latest TaskUpdate cannot be resolved', async () => {
const sessionId = sid('initial-plan-task-boundary-missing');
vi.mocked(messageService.list).mockClear();
const page = (prefix: string, startOffsetSeconds: number) =>
Array.from({ length: 50 }, (_, i) =>
dbMessage(
sessionId,
`${prefix}-${String(i).padStart(2, '0')}`,
`${prefix} message ${i}`,
new Date(BASE_TIME.getTime() + (startOffsetSeconds + i) * 1000).toISOString(),
),
);
const latestPage = page('latest', 1000);
latestPage[49] = dbToolUseMessage(
sessionId,
'latest-task-update',
'TaskUpdate',
{ taskId: 'missing', status: 'completed' },
new Date(BASE_TIME.getTime() + 2_000_000).toISOString(),
);
vi.mocked(messageService.list).mockResolvedValueOnce(latestPage);
for (let i = 0; i < 12; i += 1) {
vi.mocked(messageService.list).mockResolvedValueOnce(page(`older-${i}`, 900 - i * 100));
}
makerChatStore.ensureInitialMessages(sessionId);
await flushPromises(20);
expect(messageService.list).toHaveBeenCalledTimes(11);
expect(makerChatStore.getSnapshot(sessionId).oldestMessageId).toBe('older-9-00');
});
it('enterView disposer leaves the session', () => {
const sessionId = sid('disposer');
const dispose = enter(sessionId);
dispose();
expect(makerChatStore.__activeViewTest.getActiveSessionIds()).not.toContain(sessionId);
expect(makerChatStore.__activeViewTest.getLastViewedAt(sessionId)).toBe(BASE_TIME.getTime());
});
it('leaveView is a no-op for sessions that were never entered', () => {
const sessionId = sid('unknown');
makerChatStore.leaveView(sessionId);
expect(makerChatStore.__activeViewTest.getActiveSessionIds()).not.toContain(sessionId);
expect(makerChatStore.__activeViewTest.getLastViewedAt(sessionId)).toBeUndefined();
});
it('survives the React StrictMode enter-leave-enter sequence', () => {
const sessionId = sid('strict');
const firstDispose = enter(sessionId);
addMessage(sessionId);
firstDispose();
const secondDispose = enter(sessionId);
vi.advanceTimersByTime(90_000);
expect(makerChatStore.__activeViewTest.getActiveSessionIds()).toContain(sessionId);
expect(makerChatStore.__activeViewTest.getLastViewedAt(sessionId)).toBeUndefined();
expect(makerChatStore.getSnapshot(sessionId).messages).toHaveLength(1);
secondDispose();
});
it('keeps existing history when loading a search result window', async () => {
const sessionId = sid('search-jump');
addMessage(sessionId);
const localMessage = makerChatStore.getSnapshot(sessionId).messages[0];
vi.mocked(messageService.around).mockResolvedValueOnce([
dbMessage(sessionId, 'older', 'older search hit', '2026-05-19T00:00:00.000Z'),
dbMessage(sessionId, 'hit', 'target search hit', '2026-05-19T00:01:00.000Z'),
]);
const target = await makerChatStore.loadAroundMessage(sessionId, 'hit', { radius: 60 });
const messages = makerChatStore.getSnapshot(sessionId).messages;
expect(target?.clientId).toBe('client-hit');
expect(messages.map((message) => message.clientId)).toEqual([
'client-older',
'client-hit',
localMessage.clientId,
]);
});
it('keeps search result windows in chronological order across jumps', async () => {
const sessionId = sid('search-jump-order');
vi.mocked(messageService.around).mockResolvedValueOnce([
dbMessage(sessionId, 'older', 'older search hit', '2026-05-19T00:00:00.000Z'),
dbMessage(sessionId, 'first-hit', 'first target search hit', '2026-05-19T00:01:00.000Z'),
]);
await makerChatStore.loadAroundMessage(sessionId, 'first-hit', { radius: 60 });
expect(makerChatStore.getSnapshot(sessionId).oldestMessageId).toBe('older');
vi.mocked(messageService.around).mockResolvedValueOnce([
dbMessage(sessionId, 'later', 'later search context', '2026-05-19T00:05:00.000Z'),
dbMessage(sessionId, 'second-hit', 'second target search hit', '2026-05-19T00:06:00.000Z'),
]);
const target = await makerChatStore.loadAroundMessage(sessionId, 'second-hit', { radius: 60 });
const snapshot = makerChatStore.getSnapshot(sessionId);
expect(target?.clientId).toBe('client-second-hit');
expect(snapshot.messages.map((message) => message.clientId)).toEqual([
'client-older',
'client-first-hit',
'client-later',
'client-second-hit',
]);
expect(snapshot.oldestMessageId).toBe('older');
});
it('preserves server order for search jump messages with equal timestamps', async () => {
const sessionId = sid('search-jump-same-time');
vi.mocked(messageService.around).mockResolvedValueOnce([
dbMessage(sessionId, '001', 'first same-time message', '2026-05-19T00:00:00.000Z', 'client-z'),
dbMessage(sessionId, '002', 'target same-time message', '2026-05-19T00:00:00.000Z', 'client-a'),
dbMessage(sessionId, '003', 'third same-time message', '2026-05-19T00:00:00.000Z', 'client-m'),
]);
const target = await makerChatStore.loadAroundMessage(sessionId, '002', { radius: 60 });
const snapshot = makerChatStore.getSnapshot(sessionId);
expect(target?.clientId).toBe('client-a');
expect(snapshot.messages.map((message) => message.clientId)).toEqual([
'client-z',
'client-a',
'client-m',
]);
});
// 首拉未回来就深跳 → 只能用 around 孤岛下沿播种游标(那时窗口里只有孤岛)。首拉的最新页
// 落地后,游标必须**交还给最新页的下沿**:缺失区间比孤岛更新,继续保留更老的孤岛游标会让
// 普通翻页与孤岛感知补齐都只请求"比孤岛更老"的行,那段洞永远拉不回来(#676 review codex P1)。
// 本用例原来断言的是"保留孤岛游标",那是修复前的行为;新断言同时守住播种(跳转当时)与
// 交还(最新页落地后)两个阶段。
it('hands the cursor back to the latest page when initial history resolves after a jump', async () => {
const sessionId = sid('search-jump-initial-race');
vi.stubGlobal('window', {
electronAPI: {
maker: {
input: {
getProjection: vi.fn(async () => ({
sessionId,
pendingQueue: [],
steeringQueueClientIds: [],
queuePaused: false,
queueExpanded: false,
queueInteractionLocks: [],
queueEditLocks: [],
queueAbortPending: false,
error: null,
recovery: null,
errorRetryText: null,
})),
},
},
},
});
let resolveInitialList!: (messages: Message[]) => void;
const initialListPromise = new Promise<Message[]>((resolve) => {
resolveInitialList = resolve;
});
vi.mocked(messageService.list).mockReturnValueOnce(initialListPromise);
vi.mocked(messageService.around).mockResolvedValueOnce([
dbMessage(sessionId, 'older-hit-context', 'older context', '2026-05-19T00:00:00.000Z'),
dbMessage(sessionId, 'hit', 'target search hit', '2026-05-19T00:01:00.000Z'),
]);
makerChatStore.ensureInitialMessages(sessionId);
await makerChatStore.loadAroundMessage(sessionId, 'hit', { radius: 60 });
// 阶段一:窗口里只有孤岛 → 必须播种,游标为 null 会让下一次翻页从最新重开、把跳转位置顶掉。
expect(makerChatStore.getSnapshot(sessionId).oldestMessageId).toBe('older-hit-context');
expect(makerChatStore.getSnapshot(sessionId).historyWindowIslands).toHaveLength(1);
expect(makerChatStore.getLightSnapshot(sessionId).historyWindowHasIsland).toBe(true);
resolveInitialList([
dbMessage(sessionId, 'latest-page-oldest', 'latest page oldest', '2026-05-19T00:10:00.000Z'),
dbMessage(sessionId, 'latest-page-newest', 'latest page newest', '2026-05-19T00:11:00.000Z'),
]);
await initialListPromise;
await Promise.resolve();
await Promise.resolve();
const snapshot = makerChatStore.getSnapshot(sessionId);
expect(snapshot.messages.map((message) => message.clientId)).toEqual([
'client-older-hit-context',
'client-hit',
'client-latest-page-oldest',
'client-latest-page-newest',
]);
// 阶段二:最新页落地 → 游标交还给它的下沿,往上翻才会穿过孤岛与尾段之间的缺失区间。
expect(snapshot.oldestMessageId).toBe('latest-page-oldest');
// 洞还在,孤岛区间不清 —— 下一次跳转仍会尝试补齐。
expect(snapshot.historyWindowIslands).toHaveLength(1);
});
it('keeps loadOlder history chronological after thinking timestamps are backdated', async () => {
const sessionId = sid('older-thinking-order');
const finishedAt = Date.parse('2026-05-19T00:10:00.000Z');
vi.mocked(messageService.around).mockResolvedValueOnce([
thinkingDbMessage(
sessionId,
'thinking',
'thinking across page boundary',
'2026-05-19T00:15:00.000Z',
5 * 60 * 1000,
{ finishedAt },
),
dbMessage(sessionId, 'current', 'current page message', '2026-05-19T00:11:00.000Z'),
]);
await makerChatStore.loadAroundMessage(sessionId, 'current', { radius: 60 });
expect(makerChatStore.getSnapshot(sessionId).messages.map((message) => message.clientId)).toEqual([
'client-thinking',
'client-current',
]);
expect(makerChatStore.getSnapshot(sessionId).messages[0].createdAt).toBe('2026-05-19T00:05:00.000Z');
vi.mocked(messageService.list).mockResolvedValueOnce([
dbMessage(sessionId, 'older-db-row', 'older DB row, later display time', '2026-05-19T00:08:00.000Z'),
]);
makerChatStore.loadOlderMessages(sessionId);
await Promise.resolve();
await Promise.resolve();
const snapshot = makerChatStore.getSnapshot(sessionId);
expect(snapshot.messages.map((message) => message.clientId)).toEqual([
'client-thinking',
'client-older-db-row',
'client-current',
]);
expect(snapshot.oldestMessageId).toBe('older-db-row');
expect(snapshot.hasMoreMessages).toBe(false);
});
// 向上翻页追页回归(2026-07 用户反馈"加载不动"):单页 50 行可能整页都是同一
// turn 的工作过程(渲染层折叠后可见高度零增长),loadOlderMessages 需带着
// spinner 连续追页,直到页里出现 user 行(可见锚点)或翻完;半程失败要提交
// 已拉到的页并保持 hasMoreMessages 可重试。
describe('loadOlderMessages visible-anchor backfill paging', () => {
/** 生成一整页 50 行(newest-first),行号 newestIdx..newestIdx-49。 */
function fullPage(
sessionId: string,
newestIdx: number,
opts: { userAtIdx?: number } = {},
): Message[] {
const rows: Message[] = [];
for (let i = 0; i < 50; i++) {
const idx = newestIdx - i;
const iso = new Date(Date.parse('2026-05-01T00:00:00.000Z') + idx * 1000).toISOString();
const base = dbMessage(sessionId, `row-${idx}`, `row ${idx}`, iso);
rows.push(opts.userAtIdx === idx ? { ...base, role: 'user' } : base);
}
return rows;
}
/** 追页循环全靠 microtask 链推进,多 flush 几轮保证 10 页内的链条都跑完。 */
async function flushPagingLoop(): Promise<void> {
for (let i = 0; i < 100; i++) await Promise.resolve();
}
/** 用 loadAroundMessage 播种 oldestMessageId=current + hasMoreMessages=true。 */
async function seedSession(sessionId: string): Promise<void> {
vi.mocked(messageService.around).mockResolvedValueOnce([
dbMessage(sessionId, 'current', 'current message', '2026-05-19T00:00:00.000Z'),
]);
await makerChatStore.loadAroundMessage(sessionId, 'current', { radius: 60 });
vi.mocked(messageService.list).mockClear();
}
it('keeps paging past user-less full pages and stops at the first page with a user row', async () => {
const sessionId = sid('older-backfill-stop-at-user');
await seedSession(sessionId);
// 第 1 页整页无 user 行(模拟长 turn 中段工作过程)→ 继续追;
// 第 2 页含 user 行(turn 边界,可见锚点)→ 停,即使整页 50 行 hasMore=true。
vi.mocked(messageService.list)
.mockResolvedValueOnce(fullPage(sessionId, 999))
.mockResolvedValueOnce(fullPage(sessionId, 949, { userAtIdx: 920 }));
makerChatStore.loadOlderMessages(sessionId);
await flushPagingLoop();
expect(vi.mocked(messageService.list).mock.calls.map((call) => call[1])).toEqual([
{ limit: 50, before: 'current' },
{ limit: 50, before: 'row-950' },
]);
const snapshot = makerChatStore.getSnapshot(sessionId);
expect(snapshot.isLoadingMore).toBe(false);
expect(snapshot.hasMoreMessages).toBe(true);
expect(snapshot.oldestMessageId).toBe('row-900');
expect(snapshot.messages).toHaveLength(101); // current + 两页各 50
expect(snapshot.messages[0].clientId).toBe('client-row-900');
expect(snapshot.messages.at(-1)?.clientId).toBe('client-current');
expect(snapshot.messages.some((m) => m.clientId === 'client-row-920' && m.role === 'user')).toBe(true);
});
it('stops at MAX pages without a user row and still commits collected rows', async () => {
const sessionId = sid('older-backfill-page-cap');
await seedSession(sessionId);
// 10 页全是无 user 行的整页(游标停在同一批行也没关系,循环靠页数上限收口)。
for (let i = 0; i < 10; i++) {
vi.mocked(messageService.list).mockResolvedValueOnce(fullPage(sessionId, 999));
}
makerChatStore.loadOlderMessages(sessionId);
await flushPagingLoop();
expect(vi.mocked(messageService.list)).toHaveBeenCalledTimes(10);
const snapshot = makerChatStore.getSnapshot(sessionId);
expect(snapshot.isLoadingMore).toBe(false);
expect(snapshot.hasMoreMessages).toBe(true); // 没翻完,下次手势继续
expect(snapshot.oldestMessageId).toBe('row-950');
expect(snapshot.messages).toHaveLength(51); // current + 去重后的 50 行
});
it('commits already-fetched pages when a later page fetch fails', async () => {
const sessionId = sid('older-backfill-partial-failure');
await seedSession(sessionId);
vi.mocked(messageService.list)
.mockResolvedValueOnce(fullPage(sessionId, 999))
.mockRejectedValueOnce(new Error('tunnel dropped'));
const didAdvanceWindow = await makerChatStore.loadOlderMessages(sessionId, true);
const snapshot = makerChatStore.getSnapshot(sessionId);
expect(didAdvanceWindow).toBe(true);
expect(restoreSessionAutomaticHistoryLoadAttempts(sessionId, 5)).toBe(5);
expect(snapshot.isLoadingMore).toBe(false);
// 第 1 页已进 UI(游标推进、内容不丢),失败只终止追页,保持可重试。
expect(snapshot.hasMoreMessages).toBe(true);
expect(snapshot.oldestMessageId).toBe('row-950');
expect(snapshot.messages).toHaveLength(51);
expect(snapshot.messages[0].clientId).toBe('client-row-950');
});
it('keeps hasMoreMessages retryable when the first page fetch fails', async () => {
const sessionId = sid('older-backfill-first-failure');
await seedSession(sessionId);
vi.mocked(messageService.list).mockRejectedValueOnce(new Error('tunnel dropped'));
const didAdvanceWindow = await makerChatStore.loadOlderMessages(sessionId, true);
const snapshot = makerChatStore.getSnapshot(sessionId);
expect(didAdvanceWindow).toBe(false);
expect(restoreSessionAutomaticHistoryLoadAttempts(sessionId, 5)).toBe(0);
expect(snapshot.isLoadingMore).toBe(false);
expect(snapshot.hasMoreMessages).toBe(true);
expect(snapshot.oldestMessageId).toBe('current');
});
it('reports an empty authoritative page as no cached-window advance', async () => {
const sessionId = sid('older-backfill-empty');
await seedSession(sessionId);
vi.mocked(messageService.list).mockResolvedValueOnce([]);
const didAdvanceWindow = await makerChatStore.loadOlderMessages(sessionId, true);
expect(didAdvanceWindow).toBe(false);
expect(makerChatStore.getSnapshot(sessionId).hasMoreMessages).toBe(false);
expect(restoreSessionAutomaticHistoryLoadAttempts(sessionId, 5)).toBe(0);
});
// rewind 竞态守卫:追页 in-flight 期间 reloadMessages(rewind commit 后的强制
// 重载)把切片清空重置,晚到的翻页窗口必须整体作废——merge 回去会让服务端
// 已软删的行复活。守卫走 _messagesEpoch 代际比对。
it('discards an in-flight paging window when the session is reloaded mid-flight', async () => {
const sessionId = sid('older-backfill-reload-race');
// reloadMessages → ensureInitialMessages → reconcilePendingInteractions 需要
// window.electronAPI(与"preserves the search jump cursor"测试同款 stub)。
vi.stubGlobal('window', {
electronAPI: {
maker: {
input: {
getProjection: vi.fn(async () => ({
sessionId,
pendingQueue: [],
steeringQueueClientIds: [],
queuePaused: false,
queueExpanded: false,
queueInteractionLocks: [],
queueEditLocks: [],
queueAbortPending: false,
error: null,
recovery: null,
errorRetryText: null,
})),
},
},
},
});
await seedSession(sessionId);
let resolveOlderPage!: (rows: Message[]) => void;
const olderPagePromise = new Promise<Message[]>((resolve) => {
resolveOlderPage = resolve;
});
vi.mocked(messageService.list)
.mockReturnValueOnce(olderPagePromise) // loadOlderMessages 第 1 页(挂起中)
.mockResolvedValueOnce([]); // reloadMessages → ensureInitialMessages(重载后空历史)
markSessionAutomaticHistoryLoadCompleted(sessionId);
const loadResult = makerChatStore.loadOlderMessages(sessionId, true);
expect(makerChatStore.getSnapshot(sessionId).isLoadingMore).toBe(true);
makerChatStore.reloadMessages(sessionId);
await Promise.resolve();
expect(restoreSessionAutomaticHistoryLoadAttempts(sessionId, 5)).toBe(0);
// 翻页此刻才返回(短页 → 循环立即收口进入提交),但代际已变 → 作废。
resolveOlderPage(fullPage(sessionId, 999).slice(0, 10));
await flushPagingLoop();
const snapshot = makerChatStore.getSnapshot(sessionId);
await expect(loadResult).resolves.toBe(false);
expect(snapshot.isLoadingMore).toBe(false);
expect(snapshot.messages).toHaveLength(0); // 旧窗口没有被 merge 回清空后的切片
expect(snapshot.oldestMessageId).toBeNull();
expect(snapshot.hasMoreMessages).toBe(false);
});
it('keeps legacy single-row removal compatible with an in-flight paging window', async () => {
const sessionId = sid('older-backfill-single-delete-compat');
await seedSession(sessionId);
markSessionAutomaticHistoryLoadCompleted(sessionId);
let resolveOlderPage!: (rows: Message[]) => void;
vi.mocked(messageService.list).mockReturnValueOnce(
new Promise<Message[]>((resolve) => {
resolveOlderPage = resolve;
}),
);
makerChatStore.loadOlderMessages(sessionId);
makerChatStore.removeMessageByClientId(sessionId, 'client-current');
resolveOlderPage(fullPage(sessionId, 999).slice(0, 10));
await flushPagingLoop();
const snapshot = makerChatStore.getSnapshot(sessionId);
expect(snapshot.messages).toHaveLength(10);
expect(snapshot.messages.some((message) => message.clientId === 'client-current')).toBe(false);
expect(snapshot.isLoadingMore).toBe(false);
expect(restoreSessionAutomaticHistoryLoadAttempts(sessionId, 5)).toBe(5);
});
it('discards an in-flight paging window after grouped deletion', async () => {
const sessionId = sid('older-backfill-group-delete-race');
await seedSession(sessionId);
markSessionAutomaticHistoryLoadCompleted(sessionId);
let resolveOlderPage!: (rows: Message[]) => void;
vi.mocked(messageService.list).mockReturnValueOnce(
new Promise<Message[]>((resolve) => {
resolveOlderPage = resolve;
}),
);
makerChatStore.loadOlderMessages(sessionId);
makerChatStore.removeMessagesByClientIds(sessionId, ['client-current']);
resolveOlderPage(fullPage(sessionId, 999).slice(0, 10));
await flushPagingLoop();
const snapshot = makerChatStore.getSnapshot(sessionId);
expect(snapshot.messages).toHaveLength(0);
expect(snapshot.isLoadingMore).toBe(false);
expect(restoreSessionAutomaticHistoryLoadAttempts(sessionId, 5)).toBe(0);
});
});
// 离开时长本身不再清空窗口:用户常在几分钟后切回,任务往往已跑完。只有缓存总量
// 超出预算时才按离开先后整窗淘汰。
it('keeps a left session warm past five minutes until the total budget is exceeded', () => {
const sessionId = sid('soft-evict');
const dispose = enter(sessionId);
addMessage(sessionId);
markSessionAutomaticHistoryLoadCompleted(sessionId);
dispose();
vi.advanceTimersByTime(30 * 60_000);
expect(makerChatStore.getSnapshot(sessionId).messages).toHaveLength(1);
expect(restoreSessionAutomaticHistoryLoadAttempts(sessionId, 5)).toBe(5);
try {
makerChatStore.__activeViewTest.setSoftEvictionBudget({ messages: 0, characters: 0 });
vi.advanceTimersByTime(30_000);
} finally {
makerChatStore.__activeViewTest.setSoftEvictionBudget(null);
}
expect(makerChatStore.getSnapshot(sessionId).messages).toHaveLength(0);
expect(makerChatStore.getSnapshot(sessionId).historyLoaded).toBe(false);
expect(restoreSessionAutomaticHistoryLoadAttempts(sessionId, 5)).toBe(0);
});
it('evicts the least recently left windows first and never a mounted one', () => {
const oldest = sid('soft-evict-oldest');
const newer = sid('soft-evict-newer');
const mounted = sid('soft-evict-mounted');
for (const sessionId of [oldest, newer]) {
const dispose = enter(sessionId);
addMessage(sessionId);
vi.advanceTimersByTime(1_000);
dispose();
}
enter(mounted);
addMessage(mounted);
try {
// Three cached rows against a two-row budget: only the oldest leave goes.
makerChatStore.__activeViewTest.setSoftEvictionBudget({ messages: 2, characters: 1 << 30 });
vi.advanceTimersByTime(30_000);
expect(makerChatStore.getSnapshot(oldest).messages).toHaveLength(0);
expect(makerChatStore.getSnapshot(newer).messages).toHaveLength(1);
expect(makerChatStore.getSnapshot(mounted).messages).toHaveLength(1);
makerChatStore.__activeViewTest.setSoftEvictionBudget({ messages: 0, characters: 0 });
vi.advanceTimersByTime(30_000);
expect(makerChatStore.getSnapshot(newer).messages).toHaveLength(0);
expect(makerChatStore.getSnapshot(mounted).messages).toHaveLength(1);
} finally {
makerChatStore.__activeViewTest.setSoftEvictionBudget(null);
}
});
it('counts deeply nested, cyclic tool input toward the text budget', () => {
const sessionId = sid('soft-evict-tool-input');
// Deeply nested (and cyclic) arbitrary MCP input must still be counted.
let deepInput: Record<string, unknown> = { content: 'x'.repeat(5_000) };
for (let level = 0; level < 20; level++) deepInput = { level, nested: deepInput };
deepInput.self = deepInput;
const dispose = enter(sessionId);
makerChatStore.__applyStreamEventForTest(sessionId, {
sessionId,
type: 'tool_use',
data: { toolUseId: 'tu-write', toolName: 'Write', input: deepInput },
} as never);
dispose();
const [row] = makerChatStore.getSnapshot(sessionId).messages;
expect(row.content.length).toBeLessThan(5_000);
try {
// The summary alone fits, the full Write input does not.
makerChatStore.__activeViewTest.setSoftEvictionBudget({ messages: 100, characters: 4_000 });
vi.advanceTimersByTime(30_000);
} finally {
makerChatStore.__activeViewTest.setSoftEvictionBudget(null);
}
expect(makerChatStore.getSnapshot(sessionId).messages).toHaveLength(0);
});
it('counts every payload field, e.g. a completed plan kept outside content', async () => {
const sessionId = sid('soft-evict-plan');
const dispose = enter(sessionId);
vi.mocked(messageService.list).mockResolvedValueOnce([{
...dbMessage(sessionId, 'plan-row', '', BASE_TIME.toISOString()),
role: 'plan_review',
content: { requestId: 'plan-1', status: 'approved', plan: '# Plan\n' + 'step\n'.repeat(1_000) },
} as unknown as Message]);
makerChatStore.ensureInitialMessages(sessionId);
await flushPromises();
dispose();
const [row] = makerChatStore.getSnapshot(sessionId).messages;
expect(row).toMatchObject({ role: 'plan_review', content: '' });
try {
makerChatStore.__activeViewTest.setSoftEvictionBudget({ messages: 100, characters: 4_000 });
vi.advanceTimersByTime(30_000);
} finally {
makerChatStore.__activeViewTest.setSoftEvictionBudget(null);
}
expect(makerChatStore.getSnapshot(sessionId).messages).toHaveLength(0);
});
it('evicts a prefetched session that never enters a mounted view by budget', async () => {
const sessionId = sid('prefetch-evict');
addMessage(sessionId);
makerChatStore.ensureInitialMessages(sessionId);
await flushPromises();
expect(makerChatStore.__activeViewTest.getLastViewedAt(sessionId)).toBe(BASE_TIME.getTime());
vi.advanceTimersByTime(30 * 60_000);
expect(makerChatStore.getSnapshot(sessionId).messages).toHaveLength(1);
try {
makerChatStore.__activeViewTest.setSoftEvictionBudget({ messages: 0, characters: 0 });
vi.advanceTimersByTime(30_000);
} finally {
makerChatStore.__activeViewTest.setSoftEvictionBudget(null);
}
expect(makerChatStore.getSnapshot(sessionId).messages).toHaveLength(0);
expect(makerChatStore.getSnapshot(sessionId).historyLoaded).toBe(false);
});
// Regression: when ensureInitialMessages backfill is invalidated by an epoch
// change (e.g. reloadMessages), isLoadingMore must be released so that
// loadOlderMessages is not permanently blocked.
it('releases isLoadingMore when initial backfill is invalidated by epoch change', async () => {
const sessionId = sid('initial-backfill-invalidation-lock');
const latestPage = Array.from({ length: 49 }, (_, i) =>
dbMessage(
sessionId,
`latest-${String(i).padStart(2, '0')}`,
`latest message ${i}`,
new Date(BASE_TIME.getTime() + (60 + i) * 1000).toISOString(),
),
);
const latestPlan = dbToolUseMessage(
sessionId,
'latest-plan',
'TaskUpdate',
{ taskId: 'abc', status: 'completed' },
new Date(BASE_TIME.getTime() + 120_000).toISOString(),
);
let resolveOlderPage!: (rows: Message[]) => void;
vi.mocked(messageService.list)
.mockResolvedValueOnce([...latestPage, latestPlan])
.mockReturnValueOnce(
new Promise<Message[]>((resolve) => {
resolveOlderPage = resolve;
}),
);
makerChatStore.ensureInitialMessages(sessionId);
await flushPromises(4);
// Backfill is in progress, lock held.
expect(makerChatStore.getSnapshot(sessionId).isLoadingMore).toBe(true);
expect(messageService.list).toHaveBeenCalledTimes(2);
// Epoch change invalidates the in-flight backfill.
makerChatStore.reloadMessages(sessionId);
await Promise.resolve();
// Resolve the pending backfill — it should detect invalidation and exit.
resolveOlderPage([
dbMessage(sessionId, 'older-visible', 'older visible message', BASE_TIME.toISOString()),
]);
await flushPromises();
// isLoadingMore must have been released despite the invalidation path.
expect(makerChatStore.getSnapshot(sessionId).isLoadingMore).toBe(false);
});
});