Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
/** @vitest-environment jsdom */
import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { MemoryRouter, Route, Routes, useNavigate } from 'react-router-dom';
import type { TurnActivityGroupWire } from '../../lib/agentActivity';
import type { ModelRecoveryState, SessionRuntimeState } from '../../context/ApiContext';
import type { ComposerProps } from './Composer';
const mocks = vi.hoisted(() => ({
api: {
cancelSession: vi.fn(),
connectWorkbenchEvents: vi.fn(),
getCachedSessionDraft: vi.fn(),
getSession: vi.fn(),
getSessionActivity: vi.fn(),
getSessionActivityGroup: vi.fn(),
getSessionBootstrap: vi.fn(),
getTurnState: vi.fn(),
getWorkbenchPrefs: vi.fn(),
listSessionMessages: vi.fn(),
listSessionQueue: vi.fn(),
sendQueuedNow: vi.fn(),
mutateConfig: vi.fn(),
waitForAgentActivityConfigMutations: vi.fn(),
onSessionArchived: vi.fn(),
},
events: null as null | {
onSessionActivity: (data: { session_id: string; event: string }) => void;
onConnected: () => void;
onAuthorizationChanged: (data: {
resource_kinds?: string[];
instance_authorization_revision?: number;
}) => void;
onMessageNew: (message: ReturnType<typeof projectedMessage>) => void;
onTurnStart: (data: { session_id: string }) => void;
onTurnEnd: (data: { session_id: string }) => void;
onQueueUpdated: (data: { session_id: string }) => void;
},
composer: null as ComposerProps | null,
authorizationCapabilities: {
can_chat: true,
can_manage_instance: false,
can_use_show_pages: false,
can_use_system: false,
can_use_vault_secrets: false,
},
}));
vi.mock('react-i18next', () => ({
useTranslation: () => ({ t: (key: string) => key }),
}));
vi.mock('../../context/ApiContext', () => ({
useApi: () => mocks.api,
}));
vi.mock('../../context/ToastContext', () => ({
useToast: () => ({ showToast: vi.fn() }),
}));
vi.mock('../../context/WorkbenchInboxContext', () => ({
useWorkbenchInbox: () => ({ unreadBySession: {}, markRead: vi.fn() }),
}));
vi.mock('../../context/InstanceAuthorizationContext', () => ({
useInstanceAuthorization: () => ({
capabilities: mocks.authorizationCapabilities,
}),
}));
vi.mock('../../context/ComposerBridgeContext', () => ({
useRegisterComposerTarget: vi.fn(),
}));
vi.mock('../../context/WindowManagerContext', () => ({
useWindowManager: () => ({ focusedId: null, focusCanvas: vi.fn() }),
}));
vi.mock('../../lib/useIsDesktop', () => ({
isDesktopViewport: () => false,
useIsDesktop: () => false,
}));
vi.mock('../../lib/useIosKeyboardInset', () => ({
useIosKeyboardInset: vi.fn(),
}));
vi.mock('../../lib/useFileDrop', () => ({
useFileDrop: () => ({ dragging: false, handlers: {} }),
}));
vi.mock('../../lib/usePendingVaultRequests', () => ({
usePendingVaultRequests: () => ({ requests: [], refresh: vi.fn() }),
}));
vi.mock('./useSessionActions', () => ({
useSessionActions: () => ({
actions: [],
archiveDialog: null,
requestArchive: vi.fn(),
canArchive: false,
}),
}));
vi.mock('./useShowPageAnnotation', () => ({
useShowPageAnnotation: () => ({
state: { enabled: false, mode: 'smart' },
setIframe: vi.fn(),
handleIframeLoad: vi.fn(),
handleShortcutKeyDown: vi.fn(),
enable: vi.fn(),
disable: vi.fn(),
setMode: vi.fn(),
}),
}));
vi.mock('./Composer', () => ({
Composer: (props: ComposerProps) => {
mocks.composer = props;
return null;
},
}));
import { ChatPage } from './ChatPage';
type Deferred<T> = {
promise: Promise<T>;
resolve: (value: T) => void;
reject: (reason: unknown) => void;
};
const deferred = <T,>(): Deferred<T> => {
let resolve!: (value: T) => void;
let reject!: (reason: unknown) => void;
const promise = new Promise<T>((done, fail) => {
resolve = done;
reject = fail;
});
return { promise, resolve, reject };
};
const idleTurnState: SessionRuntimeState = {
in_flight: false,
foreground: 'idle',
native_turn_started: false,
pending_input_count: 0,
background_activities: [],
pending_activity_output_count: 0,
connection: 'connected',
};
const bootstrapPayload = (sessionId: string) => ({
session: { id: sessionId },
capabilities: { can_chat: true },
agents: [],
default_agent_name: null,
config: { ui: {} },
messages: [] as ReturnType<typeof projectedMessage>[],
next_before_id: null,
turn_state: idleTurnState,
queued: [],
draft: { text: '' },
});
const projectedMessage = (id: string, text: string) => ({
id,
scope_id: 'scope-1',
session_id: 'session-new',
platform: 'avibe',
author: 'user',
type: 'user',
source: 'user',
author_id: null,
author_name: null,
native_message_id: null,
parent_native_message_id: null,
projection: 'claimed_delivery' as const,
text,
content: {},
metadata: {},
created_at: '2026-08-15T00:00:00Z',
updated_at: '2026-08-15T00:00:00Z',
delivered_at: '2026-08-15T00:00:01Z',
read_at: null,
});
const queuedMessage = (id: string, text: string) => ({
...projectedMessage(id, text),
type: 'queued' as const,
});
const SessionSwitcher = ({ sessionId = 'session-running', label = 'switch chat', search = '' }: {
sessionId?: string;
label?: string;
search?: string;
}) => {
const navigate = useNavigate();
return <button type="button" onClick={() => navigate({ pathname: `/chat/${sessionId}`, search })}>{label}</button>;
};
describe('ChatPage transcript hydration', () => {
let sessionRow: Deferred<{ id: string }>;
let bootstrap: Deferred<never>;
beforeEach(() => {
// The transcript drives its scroll anchor and its older-page trigger from
// these two; jsdom implements neither, and nothing here depends on what they
// would report.
for (const name of ['ResizeObserver', 'IntersectionObserver']) {
vi.stubGlobal(
name,
class {
observe() {}
unobserve() {}
disconnect() {}
},
);
}
sessionRow = deferred();
bootstrap = deferred();
mocks.events = null;
mocks.composer = null;
vi.clearAllMocks();
Object.assign(mocks.authorizationCapabilities, {
can_chat: true,
can_manage_instance: false,
can_use_show_pages: false,
can_use_system: false,
can_use_vault_secrets: false,
});
mocks.api.connectWorkbenchEvents.mockImplementation((events) => {
mocks.events = events;
return () => {};
});
mocks.api.cancelSession.mockResolvedValue({ ok: true });
mocks.api.getCachedSessionDraft.mockReturnValue(null);
mocks.api.getSession.mockReturnValue(sessionRow.promise);
mocks.api.getSessionActivity.mockResolvedValue({ groups: [] });
mocks.api.getSessionActivityGroup.mockResolvedValue({});
mocks.api.getSessionBootstrap.mockReturnValue(bootstrap.promise);
mocks.api.getTurnState.mockResolvedValue(idleTurnState);
mocks.api.getWorkbenchPrefs.mockResolvedValue({});
mocks.api.listSessionMessages.mockResolvedValue({ messages: [] });
mocks.api.listSessionQueue.mockResolvedValue([]);
mocks.api.sendQueuedNow.mockResolvedValue({ ok: true, status: 'accepted' });
mocks.api.mutateConfig.mockResolvedValue({ ui: {} });
mocks.api.waitForAgentActivityConfigMutations.mockResolvedValue(undefined);
mocks.api.onSessionArchived.mockReturnValue(() => {});
});
afterEach(() => {
cleanup();
vi.unstubAllGlobals();
vi.useRealTimers();
});
it.each([
{ status: 'queued', reason: 'attachments_unavailable', notice: 'chat.queue.attachmentsUnavailable' },
{ status: 'queued', reason: 'runtime_unavailable', notice: 'chat.queue.sendDeferred' },
{ status: 'reconciling_steer', reason: undefined, notice: 'chat.queue.sendReconciling' },
])('retains the image and explains $status after send-now', async ({ status, reason, notice }) => {
const image = {
...queuedMessage('queued-image', ''),
state: 'queued',
content: { attachments: [{
token: 'image-token', name: '队列图片.png', mime: 'image/png', url: '/api/media/image-token',
}] },
};
const running = { ...idleTurnState, foreground: 'running', in_flight: true };
mocks.api.getSessionBootstrap.mockResolvedValue({
...bootstrapPayload('session-new'), queued: [image], turn_state: running,
});
mocks.api.getTurnState.mockResolvedValue(running);
mocks.api.listSessionQueue.mockResolvedValue({ queued: [{ ...image, state: status }] });
const send = deferred<{ ok: boolean; status: string; reason?: string }>();
mocks.api.sendQueuedNow.mockReturnValue(send.promise);
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes><Route path="/chat/:sessionId" element={<ChatPage />} /></Routes>
</MemoryRouter>,
);
const button = await screen.findByRole('button', { name: 'chat.queue.sendNow' });
fireEvent.click(button);
expect(screen.getByRole('button', { name: 'chat.queue.sendingNow' }).getAttribute('disabled')).not.toBeNull();
expect(mocks.api.sendQueuedNow).toHaveBeenCalledWith('session-new', 'queued-image');
expect(document.querySelector('img[src="/api/media/image-token"]')).not.toBeNull();
await act(async () => send.resolve({ ok: true, status, reason }));
await screen.findByText(notice);
expect(document.querySelector('img[src="/api/media/image-token"]')).not.toBeNull();
const control = screen.getByRole('button', {
name: status === 'reconciling_steer' ? 'chat.queue.confirmingNow' : 'chat.queue.sendNow',
}) as HTMLButtonElement;
expect(control.disabled).toBe(status === 'reconciling_steer');
expect(mocks.api.cancelSession).not.toHaveBeenCalled();
});
it('refreshes a stale queue snapshot after send-now transport failure', async () => {
const queued = {
...queuedMessage('stale-queued-row', 'stale queued row'),
state: 'queued' as const,
};
const running = { ...idleTurnState, foreground: 'running', in_flight: true };
mocks.api.getSessionBootstrap.mockResolvedValue({
...bootstrapPayload('session-new'),
queued: [queued],
turn_state: running,
});
mocks.api.getTurnState.mockResolvedValue(running);
mocks.api.listSessionQueue.mockResolvedValue({ queued: [] });
mocks.api.sendQueuedNow.mockRejectedValue(new Error('socket unavailable'));
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes><Route path="/chat/:sessionId" element={<ChatPage />} /></Routes>
</MemoryRouter>,
);
const button = await screen.findByRole('button', { name: 'chat.queue.sendNow' });
expect(screen.getByText(queued.text)).toBeTruthy();
fireEvent.click(button);
await screen.findByText('chat.queue.sendStatusUnknown');
await waitFor(() => expect(screen.queryByText(queued.text)).toBeNull());
expect(mocks.api.listSessionQueue).toHaveBeenCalledWith('session-new', { cache: false });
expect(screen.queryByText('chat.stopFailed')).toBeNull();
});
it('does not overwrite a newer chat after a stale send-now refresh finishes', async () => {
const queued = {
...queuedMessage('stale-send-row', 'stale send row'),
state: 'queued' as const,
};
const running = { ...idleTurnState, foreground: 'running', in_flight: true };
const queueRefresh = deferred<{ queued: (typeof queued)[] }>();
let holdQueueRefresh = false;
mocks.api.getSession.mockImplementation((id: string) => Promise.resolve({ id }));
mocks.api.getSessionBootstrap.mockImplementation((id: string) => Promise.resolve({
...bootstrapPayload(id),
queued: id === 'session-new' ? [queued] : [],
turn_state: id === 'session-new' ? running : idleTurnState,
}));
mocks.api.getTurnState.mockResolvedValue(running);
mocks.api.listSessionQueue.mockImplementation((id: string) => {
if (id === 'session-new' && holdQueueRefresh) return queueRefresh.promise;
return Promise.resolve({ queued: id === 'session-new' ? [queued] : [] });
});
mocks.api.sendQueuedNow.mockImplementation(async () => {
holdQueueRefresh = true;
throw new Error('socket unavailable');
});
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes>
<Route
path="/chat/:sessionId"
element={(
<>
<SessionSwitcher sessionId="session-other" />
<ChatPage />
</>
)}
/>
</Routes>
</MemoryRouter>,
);
fireEvent.click(await screen.findByRole('button', { name: 'chat.queue.sendNow' }));
await waitFor(() => expect(mocks.api.sendQueuedNow).toHaveBeenCalledWith('session-new', 'stale-send-row'));
fireEvent.click(screen.getByRole('button', { name: 'switch chat' }));
await act(async () => queueRefresh.resolve({ queued: [] }));
await waitFor(() => expect(screen.queryByText('chat.queue.sendStatusUnknown')).toBeNull());
expect(screen.queryByText('chat.queue.sendFailed')).toBeNull();
});
it.each(
['rejected send', 'refused send', 'accepted send', 'rejected refresh', 'refused refresh']
.flatMap((phase) => [false, true].map((newerSend) => ({ phase, newerSend }))),
)('does not revive a stale $phase after A → B → A (new send: $newerSend)', async ({ phase, newerSend }) => {
const queued = {
...queuedMessage('stale-return-row', 'stale return row'),
state: 'queued' as const,
};
const running = { ...idleTurnState, foreground: 'running', in_flight: true };
const send = deferred<{ ok: boolean; code?: string; status?: string }>();
const nextSend = deferred<{ ok: boolean; status: string }>();
const queueRefresh = deferred<{ queued: (typeof queued)[] }>();
const settleSend = () => {
if (phase.startsWith('rejected')) send.reject(new Error('socket unavailable'));
else if (phase.startsWith('refused')) send.resolve({ ok: false, code: 'stale_head' });
else send.resolve({ ok: true, status: 'accepted' });
};
mocks.api.getSession.mockImplementation((id: string) => Promise.resolve({ id }));
mocks.api.getSessionBootstrap.mockImplementation((id: string) => Promise.resolve({
...bootstrapPayload(id),
queued: id === 'session-new' ? [queued] : [],
turn_state: running,
}));
mocks.api.getTurnState.mockResolvedValue(running);
mocks.api.listSessionQueue.mockReturnValue(queueRefresh.promise);
mocks.api.sendQueuedNow.mockReturnValueOnce(send.promise).mockReturnValue(nextSend.promise);
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes>
<Route
path="/chat/:sessionId"
element={(
<>
<SessionSwitcher sessionId="session-other" />
<SessionSwitcher sessionId="session-new" label="return chat" />
<ChatPage />
</>
)}
/>
</Routes>
</MemoryRouter>,
);
fireEvent.click(await screen.findByRole('button', { name: 'chat.queue.sendNow' }));
await waitFor(() => expect(mocks.api.sendQueuedNow).toHaveBeenCalledWith('session-new', 'stale-return-row'));
if (phase.endsWith('refresh')) {
await act(async () => settleSend());
await waitFor(() => expect(mocks.api.listSessionQueue).toHaveBeenCalledTimes(1));
}
fireEvent.click(screen.getByRole('button', { name: 'switch chat' }));
await waitFor(() => expect(mocks.composer?.sessionId).toBe('session-other'));
expect(screen.queryByText(queued.text)).toBeNull();
fireEvent.click(await screen.findByRole('button', { name: 'return chat' }));
await screen.findByText(queued.text);
if (newerSend) fireEvent.click(screen.getByRole('button', { name: 'chat.queue.sendNow' }));
if (phase.endsWith('send')) await act(async () => settleSend());
await act(async () => queueRefresh.resolve({ queued: [] }));
expect(screen.queryByText('chat.queue.sendStatusUnknown')).toBeNull();
expect(screen.queryByText('chat.queue.sendFailed')).toBeNull();
expect(screen.getByText(queued.text)).toBeTruthy();
expect(mocks.composer?.busy).toBe(true);
const button = screen.getByRole('button', {
name: newerSend ? 'chat.queue.sendingNow' : 'chat.queue.sendNow',
}) as HTMLButtonElement;
expect(button.disabled).toBe(newerSend);
expect(mocks.api.listSessionQueue).toHaveBeenCalledTimes(phase.endsWith('refresh') ? 1 : 0);
expect(mocks.api.cancelSession).not.toHaveBeenCalled();
if (newerSend) {
await act(async () => nextSend.resolve({ ok: true, status: 'accepted' }));
expect(screen.queryByRole('button', { name: 'chat.queue.sendingNow' })).toBeNull();
}
});
it.each(
['transport', 'stale_head', 'internal_unavailable', 'ordering_fence', 'stop_failed'].flatMap((failure) =>
['queued', 'gone', 'unreadable', 'superseded', 'pending_steer', 'steering', 'reconciling_steer'].map((state) => ({
failure, state,
})),
),
)('reconciles $failure against an exact row that is $state', async ({ failure, state }) => {
const queued = {
...queuedMessage('stale-head-row', 'stale head row'),
state: 'queued',
};
const running = { ...idleTurnState, foreground: 'running', in_flight: true };
const otherRow = { ...queued, id: 'another-row', text: 'another queued message' };
const queueRefresh = deferred<{ queued: (typeof queued)[] }>();
mocks.api.getSessionBootstrap.mockResolvedValue({
...bootstrapPayload('session-new'),
queued: [queued],
turn_state: running,
});
mocks.api.getTurnState.mockResolvedValue(running);
mocks.api.listSessionQueue.mockReturnValue(queueRefresh.promise);
mocks.api.sendQueuedNow.mockImplementation(async () => {
if (failure === 'transport') throw new Error('controller socket unavailable');
return { ok: false, code: failure, detail: 'controller socket unavailable' };
});
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes><Route path="/chat/:sessionId" element={<ChatPage />} /></Routes>
</MemoryRouter>,
);
fireEvent.click(await screen.findByRole('button', { name: 'chat.queue.sendNow' }));
await waitFor(() => expect(mocks.api.listSessionQueue).toHaveBeenCalledTimes(1));
// Never flash retry advice before the reconciliation evidence arrives.
expect(screen.queryByText('chat.queue.sendFailed')).toBeNull();
if (state === 'superseded') {
mocks.api.listSessionQueue.mockResolvedValue({ queued: [otherRow] });
act(() => {
mocks.events?.onTurnStart({ session_id: 'session-new' });
mocks.events?.onQueueUpdated({ session_id: 'session-new' });
});
await screen.findByText(otherRow.text);
expect(screen.queryByText(queued.text)).toBeNull();
}
await act(async () => {
if (state === 'unreadable') queueRefresh.reject(new Error('queue unavailable'));
else queueRefresh.resolve({
queued: state === 'gone' ? [otherRow] : [
{ ...queued, state: state === 'superseded' ? 'queued' : state }, otherRow,
],
});
});
const expectedNotice = state === 'queued' ? 'chat.queue.sendFailed' : 'chat.queue.sendStatusUnknown';
await screen.findByText(expectedNotice);
expect(screen.queryByText('controller socket unavailable')).toBeNull();
if (state !== 'queued') expect(screen.queryByText('chat.queue.sendFailed')).toBeNull();
if (state === 'gone' || state === 'superseded') {
expect(screen.queryByText(queued.text)).toBeNull();
expect(screen.getByText(otherRow.text)).toBeTruthy();
} else {
expect(screen.getByText(queued.text)).toBeTruthy();
}
if (['pending_steer', 'steering', 'reconciling_steer'].includes(state)) {
const name = state === 'reconciling_steer' ? 'chat.queue.confirmingNow' : 'chat.queue.sendingNow';
expect((screen.getByRole('button', { name }) as HTMLButtonElement).disabled).toBe(true);
// The server's fence remains authoritative, but the HTTP invocation's
// spinner must already be released once that fence settles.
mocks.api.listSessionQueue.mockResolvedValue({ queued: [queued, otherRow] });
act(() => mocks.events?.onQueueUpdated({ session_id: 'session-new' }));
}
const retryButton = await screen.findByRole('button', { name: 'chat.queue.sendNow' });
expect((retryButton as HTMLButtonElement).disabled).toBe(false);
expect(mocks.composer?.busy).toBe(failure === 'stop_failed' || state === 'superseded');
expect(mocks.api.sendQueuedNow).toHaveBeenCalledTimes(1);
expect(mocks.api.cancelSession).not.toHaveBeenCalled();
});
it('does not present send-now refusal as a stop failure', async () => {
const queued = {
...queuedMessage('refused-queued-row', 'refused queued row'),
state: 'queued' as const,
};
const running = { ...idleTurnState, foreground: 'running', in_flight: true };
mocks.api.getSessionBootstrap.mockResolvedValue({
...bootstrapPayload('session-new'),
queued: [queued],
turn_state: running,
});
mocks.api.getTurnState.mockResolvedValue(running);
mocks.api.listSessionQueue.mockResolvedValue({ queued: [queued] });
mocks.api.sendQueuedNow.mockResolvedValue({
ok: false,
code: 'internal_unavailable',
detail: 'controller socket unavailable',
});
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes><Route path="/chat/:sessionId" element={<ChatPage />} /></Routes>
</MemoryRouter>,
);
fireEvent.click(await screen.findByRole('button', { name: 'chat.queue.sendNow' }));
await screen.findByText('chat.queue.sendFailed');
expect(screen.queryByText('chat.stopFailed')).toBeNull();
expect(screen.queryByText('controller socket unavailable')).toBeNull();
expect(screen.getByText(queued.text)).toBeTruthy();
});
it.each(['accepted', 'queued'])('restores a confirming image on reload and follows $status settlement', async (settlement) => {
const image = {
...queuedMessage('queued-image', ''),
state: 'reconciling_steer',
content: { attachments: [{
token: 'image-token', name: '队列图片.png', mime: 'image/png', url: '/api/media/image-token',
}] },
};
mocks.api.getSessionBootstrap.mockResolvedValue({
...bootstrapPayload('session-new'), queued: [image],
});
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes><Route path="/chat/:sessionId" element={<ChatPage />} /></Routes>
</MemoryRouter>,
);
const confirming = await screen.findByRole('button', { name: 'chat.queue.confirmingNow' });
expect((confirming as HTMLButtonElement).disabled).toBe(true);
expect(document.querySelector('img[src="/api/media/image-token"]')).not.toBeNull();
fireEvent.click(confirming);
expect(mocks.api.sendQueuedNow).not.toHaveBeenCalled();
mocks.api.listSessionQueue.mockResolvedValue({
queued: settlement === 'accepted' ? [] : [{ ...image, state: 'queued' }],
});
act(() => mocks.events?.onQueueUpdated({ session_id: 'session-new' }));
await waitFor(() => expect(screen.queryByRole('button', { name: 'chat.queue.confirmingNow' })).toBeNull());
expect(screen.queryByText('chat.queue.sendReconciling')).toBeNull();
if (settlement === 'queued') {
expect((screen.getByRole('button', { name: 'chat.queue.sendNow' }) as HTMLButtonElement).disabled).toBe(false);
expect(document.querySelector('img[src="/api/media/image-token"]')).not.toBeNull();
} else {
expect(document.querySelector('[data-queue-row]')).toBeNull();
act(() => mocks.events?.onMessageNew({ ...image, type: 'user' }));
expect(document.querySelector('img[src="/api/media/image-token"]')).not.toBeNull();
}
});
it.each(['live tail', 'search history'])(
'offers the latest Agent reply body as dictation context from the %s',
async (view) => {
const prompt = { ...projectedMessage('prompt', 'deploy it'), projection: undefined };
const olderReply = {
...prompt, id: 'older-reply', author: 'agent', type: 'result', source: 'agent', text: 'Older reply',
delivered_at: '2026-08-15T00:00:02Z',
};
const reply = {
...olderReply,
id: 'latest-reply',
text: 'Run make release on prod-7.\n\n✅ 12s · 3k tokens',
content: { result_footer: '✅ 12s · 3k tokens' },
delivered_at: '2026-08-15T00:00:03Z',
};
mocks.api.getSession.mockResolvedValue({ id: 'session-new' });
mocks.api.getSessionBootstrap.mockResolvedValue({
...bootstrapPayload('session-new'),
messages: [prompt, olderReply, reply],
});
// The searched window holds an old reply, not the chat's latest one.
mocks.api.listSessionMessages.mockResolvedValue({
messages: [
{ ...projectedMessage('historical-prompt', 'historical prompt'), projection: undefined },
{ ...olderReply, id: 'historical-reply', text: 'historical reply' },
],
next_after_id: 'historical-reply',
});
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<SessionSwitcher sessionId="session-new" search="?msg=historical-prompt" label="read history" />
<Routes><Route path="/chat/:sessionId" element={<ChatPage />} /></Routes>
</MemoryRouter>,
);
await screen.findByText('Run make release on prod-7.');
if (view === 'search history') {
act(() => screen.getByRole('button', { name: 'read history' }).click());
await screen.findByText('historical prompt');
} else {
// A later prompt starts a Turn; the committed reply stays the context.
act(() => mocks.events?.onMessageNew({
...prompt, id: 'next-prompt', text: 'and then?', delivered_at: '2026-08-15T00:00:04Z',
}));
await screen.findByText('and then?');
}
expect(mocks.composer?.readLatestAgentReply?.()).toBe(
view === 'live tail' ? 'Run make release on prod-7.' : undefined,
);
},
);
it('keeps the loading view when SSE Session-row recovery beats transcript bootstrap', async () => {
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
await act(async () => Promise.resolve());
expect(mocks.events).not.toBeNull();
act(() => mocks.events?.onConnected());
await act(async () => sessionRow.resolve({ id: 'session-new' }));
expect(screen.getByText('common.loading')).toBeTruthy();
expect(screen.queryByText('chat.transcriptEmpty')).toBeNull();
});
it('ignores a bootstrap failure after a newer same-route refresh starts', async () => {
const staleBootstrap = deferred<never>();
const currentBootstrap = deferred<never>();
mocks.api.getSession.mockResolvedValue({ id: 'session-new' });
mocks.api.getSessionBootstrap
.mockReset()
.mockReturnValueOnce(staleBootstrap.promise)
.mockReturnValueOnce(currentBootstrap.promise);
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
await waitFor(() => expect(mocks.api.getSessionBootstrap).toHaveBeenCalledTimes(1));
act(() => mocks.events?.onAuthorizationChanged({ resource_kinds: [] }));
await waitFor(() => expect(mocks.api.getSessionBootstrap).toHaveBeenCalledTimes(2));
await act(async () => staleBootstrap.reject(new Error('stale bootstrap failed')));
expect(screen.getByText('common.loading')).toBeTruthy();
expect(screen.queryByText('stale bootstrap failed')).toBeNull();
});
it('ignores a bootstrap success after a newer same-route refresh starts', async () => {
const staleBootstrap = deferred<ReturnType<typeof bootstrapPayload>>();
const currentBootstrap = deferred<never>();
mocks.api.getSession.mockResolvedValue({ id: 'session-new' });
mocks.api.getSessionBootstrap
.mockReset()
.mockReturnValueOnce(staleBootstrap.promise)
.mockReturnValueOnce(currentBootstrap.promise);
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
await waitFor(() => expect(mocks.api.getSessionBootstrap).toHaveBeenCalledTimes(1));
act(() => mocks.events?.onAuthorizationChanged({ resource_kinds: [] }));
await waitFor(() => expect(mocks.api.getSessionBootstrap).toHaveBeenCalledTimes(2));
await act(async () => staleBootstrap.resolve(bootstrapPayload('session-new')));
expect(screen.getByText('common.loading')).toBeTruthy();
expect(screen.queryByText('chat.transcriptEmpty')).toBeNull();
});
it('removes a retired claimed Delivery projection during reconnect recovery', async () => {
const projected = projectedMessage('delivery-claimed', 'claimed input still visible');
mocks.api.getSession.mockResolvedValue({ id: 'session-new' });
mocks.api.getSessionBootstrap.mockResolvedValue({
...bootstrapPayload('session-new'),
messages: [projected],
});
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
await waitFor(() => expect(screen.getByText(projected.text)).toBeTruthy());
act(() => mocks.events?.onConnected());
await waitFor(() => expect(screen.queryByText(projected.text)).toBeNull());
expect(mocks.api.listSessionMessages).toHaveBeenCalledWith('session-new', {
limit: 50,
tail: true,
cache: false,
});
});
it('does not let an older recovery resurrect a projection after settlement', async () => {
const projected = projectedMessage('delivery-racing-recovery', 'stale projected input');
const staleRecovery = deferred<{ messages: typeof projected[] }>();
const settledRecovery = deferred<{ messages: never[] }>();
mocks.api.getSession.mockResolvedValue({ id: 'session-new' });
mocks.api.getSessionBootstrap.mockResolvedValue({
...bootstrapPayload('session-new'),
messages: [projected],
});
mocks.api.listSessionMessages
.mockReset()
.mockReturnValueOnce(staleRecovery.promise)
.mockReturnValueOnce(settledRecovery.promise);
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
await waitFor(() => expect(screen.getByText(projected.text)).toBeTruthy());
act(() => mocks.events?.onConnected());
await waitFor(() => expect(mocks.api.listSessionMessages).toHaveBeenCalledTimes(1));
act(() => mocks.events?.onTurnEnd({ session_id: 'session-new' }));
await waitFor(() => expect(mocks.api.listSessionMessages).toHaveBeenCalledTimes(2));
await act(async () => settledRecovery.resolve({ messages: [] }));
await waitFor(() => expect(screen.queryByText(projected.text)).toBeNull());
await act(async () => staleRecovery.resolve({ messages: [projected] }));
expect(screen.queryByText(projected.text)).toBeNull();
});
it('does not let an older bootstrap resurrect a projection after recovery', async () => {
const projected = projectedMessage('delivery-racing-bootstrap', 'stale bootstrap projection');
const staleBootstrap = deferred<ReturnType<typeof bootstrapPayload> & { messages: typeof projected[] }>();
mocks.api.getSession.mockResolvedValue({ id: 'session-new' });
mocks.api.getSessionBootstrap.mockReset().mockReturnValue(staleBootstrap.promise);
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
await waitFor(() => expect(mocks.events).not.toBeNull());
act(() => mocks.events?.onConnected());
await waitFor(() => expect(mocks.api.listSessionMessages).toHaveBeenCalledTimes(1));
await act(async () => staleBootstrap.resolve({
...bootstrapPayload('session-new'),
messages: [projected],
}));
await waitFor(() => expect(screen.getByText('chat.transcriptEmpty')).toBeTruthy());
expect(screen.queryByText(projected.text)).toBeNull();
});
it('does not let an older queue refresh overwrite a newer queue snapshot', async () => {
const staleRefresh = deferred<{ queued: ReturnType<typeof queuedMessage>[] }>();
const currentRefresh = deferred<{ queued: ReturnType<typeof queuedMessage>[] }>();
const stale = queuedMessage('queued-stale', 'stale queued row');
const current = queuedMessage('queued-current', 'new queued row');
mocks.api.getSession.mockResolvedValue({ id: 'session-new' });
mocks.api.getSessionBootstrap.mockResolvedValue(bootstrapPayload('session-new'));
mocks.api.listSessionQueue
.mockReset()
.mockReturnValueOnce(staleRefresh.promise)
.mockReturnValueOnce(currentRefresh.promise);
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
await waitFor(() => expect(mocks.events).not.toBeNull());
act(() => {
mocks.events?.onQueueUpdated({ session_id: 'session-new' });
mocks.events?.onQueueUpdated({ session_id: 'session-new' });
});
await waitFor(() => expect(mocks.api.listSessionQueue).toHaveBeenCalledTimes(2));
await act(async () => currentRefresh.resolve({ queued: [current] }));
await waitFor(() => expect(screen.getByText(current.text)).toBeTruthy());
await act(async () => staleRefresh.resolve({ queued: [stale] }));
expect(screen.getByText(current.text)).toBeTruthy();
expect(screen.queryByText(stale.text)).toBeNull();
});
it('does not let delayed bootstrap erase a newer queue refresh', async () => {
const delayedBootstrap = deferred<ReturnType<typeof bootstrapPayload>>();
const current = queuedMessage('bootstrap-current', 'current queued row');
mocks.api.getSession.mockResolvedValue({ id: 'session-new' });
mocks.api.getSessionBootstrap.mockReset().mockReturnValue(delayedBootstrap.promise);
mocks.api.listSessionQueue.mockReset().mockResolvedValue({ queued: [current] });
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
await waitFor(() => expect(mocks.api.getSessionBootstrap).toHaveBeenCalledTimes(1));
await act(async () => mocks.events?.onQueueUpdated({ session_id: 'session-new' }));
expect(mocks.api.listSessionQueue).toHaveBeenCalledTimes(1);
await act(async () => delayedBootstrap.resolve(bootstrapPayload('session-new')));
expect(screen.getByText(current.text)).toBeTruthy();
});
it('does not let an older queue refresh erase a newer bootstrap snapshot', async () => {
const staleRefresh = deferred<{ queued: ReturnType<typeof queuedMessage>[] }>();
const current = queuedMessage('bootstrap-current', 'current bootstrap row');
mocks.api.getSession.mockResolvedValue({ id: 'session-new' });
mocks.api.getSessionBootstrap.mockResolvedValue(bootstrapPayload('session-new'));
mocks.api.listSessionQueue.mockReset().mockReturnValue(staleRefresh.promise);
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
await waitFor(() => expect(screen.queryByText('common.loading')).toBeNull());
act(() => mocks.events?.onQueueUpdated({ session_id: 'session-new' }));
await waitFor(() => expect(mocks.api.listSessionQueue).toHaveBeenCalledTimes(1));
mocks.api.getSessionBootstrap.mockResolvedValue({
...bootstrapPayload('session-new'),
queued: [current],
});
act(() => mocks.events?.onAuthorizationChanged({ resource_kinds: [] }));
await waitFor(() => expect(screen.getByText(current.text)).toBeTruthy());
await act(async () => staleRefresh.resolve({ queued: [] }));
expect(screen.getByText(current.text)).toBeTruthy();
});
it('keeps an older successful queue read after a newer read fails', async () => {
const olderRead = deferred<{ queued: ReturnType<typeof queuedMessage>[] }>();
const newerRead = deferred<{ queued: ReturnType<typeof queuedMessage>[] }>();
const current = queuedMessage('queue-fallback', 'fallback queued row');
mocks.api.getSession.mockResolvedValue({ id: 'session-new' });
mocks.api.getSessionBootstrap.mockResolvedValue(bootstrapPayload('session-new'));
mocks.api.listSessionQueue
.mockReset()
.mockReturnValueOnce(olderRead.promise)
.mockReturnValueOnce(newerRead.promise);
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
await waitFor(() => expect(mocks.events).not.toBeNull());
act(() => {
mocks.events?.onQueueUpdated({ session_id: 'session-new' });
mocks.events?.onQueueUpdated({ session_id: 'session-new' });
});
await waitFor(() => expect(mocks.api.listSessionQueue).toHaveBeenCalledTimes(2));
await act(async () => newerRead.reject(new Error('newer queue read failed')));
await act(async () => olderRead.resolve({ queued: [current] }));
expect(screen.getByText(current.text)).toBeTruthy();
});
it.each([
{ kind: 'detached', type: 'result', metadata: { detached: true, activity_id: 'background-1' } },
{
kind: 'replayed restart', type: 'notify',
metadata: {
event: 'backend_failure', replayed: true, detached: false,
turn_id: 'interrupted-turn', failure_id: 'turn:interrupted-turn',
},
},
])('refreshes $kind Activity without settling the current live generation', async ({ type, metadata }) => {
// MESSAGE-DELIVERY-030: the old notice must not retire newer live UI work.
mocks.api.getSession.mockResolvedValue({ id: 'session-new' });
mocks.api.getSessionBootstrap.mockResolvedValue({
...bootstrapPayload('session-new'),
config: { ui: { show_agent_activity: true } },
});
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
await waitFor(() => expect(mocks.api.getSessionActivity).toHaveBeenCalled());
mocks.api.getSessionActivity.mockClear();
const detachedRefresh = deferred<{ groups: never[] }>();
mocks.api.getSessionActivity.mockReturnValue(detachedRefresh.promise);
act(() => {
mocks.events?.onTurnStart({ session_id: 'session-new' });
mocks.events?.onMessageNew({
...projectedMessage('active-step-1', 'first active step'),
author: 'agent',
type: 'assistant',
source: 'agent',
});
mocks.events?.onMessageNew({
...projectedMessage('old-completion', 'earlier work ended'),
author: 'agent',
type,
source: 'agent',
metadata,
});
mocks.events?.onMessageNew({
...projectedMessage('active-step-2', 'second active step'),
author: 'agent',
type: 'assistant',
source: 'agent',
});
});
await waitFor(() => expect(mocks.api.getSessionActivity).toHaveBeenCalledTimes(1));
expect(screen.getByText('first active step')).toBeTruthy();
expect(screen.getByText('second active step')).toBeTruthy();
});
it('refreshes live interrupted searches from the same durable projection used on reload', async () => {
// SSE arrival itself is not retry evidence: only the read-side projection can add it.
mocks.api.getSession.mockResolvedValue({ id: 'session-new' });
mocks.api.getSessionBootstrap.mockResolvedValue({
...bootstrapPayload('session-new'), config: { ui: { show_agent_activity: true } },
});
render(<MemoryRouter initialEntries={['/chat/session-new']}><Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes></MemoryRouter>);
await waitFor(() => expect(mocks.api.getSessionActivity).toHaveBeenCalled());
const hosted = { version: 1, call_id: 'ws_cut', tool: 'web_search', mode: 'native', status: 'pending',
action: 'other', interruption: 'overloaded', sources: [], images: [] };
act(() => {
mocks.events?.onTurnStart({ session_id: 'session-new' });
mocks.events?.onMessageNew({ ...projectedMessage('cut', 'cut off'), author: 'agent', type: 'tool_call',
content: { hosted } });
});
expect(screen.getByText('chat.agentActivity.hosted.interruption.message')).toBeTruthy();
mocks.api.getSessionActivity.mockClear();
const group = { id: 'cut', anchor_message_id: null, anchor_position: 'after', open: true, status: 'interrupted', steps: 2, duration_ms: null };
mocks.api.getSessionActivity.mockResolvedValue({ groups: [group] });
mocks.api.getSessionActivityGroup.mockResolvedValue({ ...group, rows: [{
id: 'cut', kind: 'tool_call', text: 'cut off', created_at: '2026-08-15T00:00:00Z', hosted: { ...hosted, retried: true },
}] });
act(() => mocks.events?.onMessageNew({ ...projectedMessage('later', 'continued'), author: 'agent', type: 'assistant' }));
await waitFor(() => expect(mocks.api.getSessionActivity).toHaveBeenCalled());
await waitFor(() => expect(screen.getByText(/chat.agentActivity.hosted.interruption.retried/)).toBeTruthy());
});
describe.each([false, true])('restart notice with Activity enabled=%s', (activityEnabled) => {
it.each(['live', 'bootstrap'])('keeps newer work thinking after a %s notice', async (delivery) => {
// MESSAGE-DELIVERY-030: cover both message.new and a persisted reload.
const notice = {
...projectedMessage('restart-notice', '服务重启导致上一轮中断'),
author: 'agent', source: 'agent', type: 'notify',
metadata: {
event: 'backend_failure', replayed: true, detached: false,
turn_id: 'interrupted-turn', failure_id: 'turn:interrupted-turn',
},
};
mocks.api.getSession.mockResolvedValue({ id: 'session-new' });
mocks.api.getSessionBootstrap.mockResolvedValue({
...bootstrapPayload('session-new'),
config: { ui: { show_agent_activity: activityEnabled } },
turn_state: { ...idleTurnState, foreground: 'running', in_flight: true },
messages: delivery === 'bootstrap' ? [notice] : [],
});
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
await screen.findByText('chat.thinking');
if (delivery === 'live') act(() => mocks.events?.onMessageNew(notice));
expect(screen.getByText(notice.text, { exact: false })).toBeTruthy();
expect(screen.getByText('chat.thinking')).toBeTruthy();
expect(screen.getByRole('button', { name: 'common.retry' })).toBeTruthy();
expect(mocks.composer?.busy).toBe(true);
// A real foreground failure still ends its visible response immediately.
act(() => mocks.events?.onMessageNew({
...notice, id: 'zz-current-failure', created_at: '2026-08-15T00:01:00Z', metadata: {
event: 'backend_failure', turn_id: 'current-turn', failure_id: 'current-failure',
},
}));
expect(screen.queryByText('chat.thinking')).toBeNull();
});
});
describe.each([false, true])('reply before the Turn ends with Activity enabled=%s', (activityEnabled) => {
it('MESSAGE-DELIVERY-334 keeps the Turn thinking after a reply until turn.end', async () => {
// A Turn may reply more than once (a steered input is answered in the same
// Turn), so a reply is drawn as the Agent's answer and only turn.end settles.
mocks.api.getSession.mockResolvedValue({ id: 'session-new' });
mocks.api.getSessionBootstrap.mockResolvedValue({
...bootstrapPayload('session-new'),
config: { ui: { show_agent_activity: activityEnabled } },
turn_state: { ...idleTurnState, foreground: 'running', in_flight: true },
messages: [projectedMessage('owner-start', '修一下缓存')],
});
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
await screen.findByText('chat.thinking');
act(() => mocks.events?.onMessageNew({
...projectedMessage('first-reply', '缓存已修好。'),
author: 'agent', source: 'agent', type: 'result',
created_at: '2026-08-15T00:00:30Z',
metadata: { turn_id: 'current-turn' },
}));
const row = document.querySelector('[data-message-id="first-reply"]');
expect(row!.textContent).toContain('缓存已修好。');
// The Agent's answer, not the muted phase bubble.
expect(row!.querySelector('.border-mint\\/25')).not.toBeNull();
expect(screen.getByText('chat.thinking')).toBeTruthy();
expect(mocks.composer?.busy).toBe(true);
act(() => mocks.events?.onTurnEnd({ session_id: 'session-new' }));
expect(screen.queryByText('chat.thinking')).toBeNull();
});
});
describe.each([false, true])('retried failure with Activity enabled=%s', (activityEnabled) => {
it.each(['live', 'bootstrap'])('keeps the retried work thinking after a %s retry admission', async (delivery) => {
// Vibey's retry resumes the transcript and adds no row after the notice, so the
// notice stays the last row while the retried work runs.
const failure = {
...projectedMessage('failure-notice', 'Vibey 因内部错误而停止'),
author: 'agent', source: 'agent', type: 'notify',
metadata: { event: 'backend_failure', turn_id: 'failed-turn', failure_id: 'failed-turn' },
};
const retried = { ...failure, content: { failure_retry: { delivery_id: 'retry', state: 'accepted' } } };
mocks.api.getSession.mockResolvedValue({ id: 'session-new' });
mocks.api.getSessionBootstrap.mockResolvedValue({
...bootstrapPayload('session-new'),
config: { ui: { show_agent_activity: activityEnabled } },
turn_state: { ...idleTurnState, foreground: 'running', in_flight: true },
messages: [delivery === 'bootstrap' ? retried : failure],
});
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
await screen.findByText(failure.text, { exact: false });
if (delivery === 'live') {
// Before its Retry is admitted the failure still ends the visible response.
expect(screen.queryByText('chat.thinking')).toBeNull();
act(() => mocks.events?.onMessageUpdated(retried));
act(() => mocks.events?.onTurnStart({ session_id: 'session-new' }));
}
expect(await screen.findByText('chat.thinking')).toBeTruthy();
expect(mocks.composer?.busy).toBe(true);
});
});
describe.each([false, true])('Computer Use script prompt with Activity enabled=%s', (activityEnabled) => {
it('MESSAGE-DELIVERY-035 draws the confirm prompt as a visible Agent message while the Turn runs', async () => {
// The prompt lands mid-Turn over message.new; the owner must notice it and
// reply, so it is the Agent's bubble rather than a compact status pill.
const prompt = {
...projectedMessage('confirm-prompt', '计算器里已输入 6 × 7,下一步要按「=」。请回复“是”或“否”。'),
author: 'agent', source: 'agent', type: 'notify',
created_at: '2026-08-15T00:00:30Z',
metadata: { event: 'computer_script_confirm', turn_id: 'current-turn', detached: false },
};
mocks.api.getSession.mockResolvedValue({ id: 'session-new' });
mocks.api.getSessionBootstrap.mockResolvedValue({
...bootstrapPayload('session-new'),
config: { ui: { show_agent_activity: activityEnabled } },
turn_state: { ...idleTurnState, foreground: 'running', in_flight: true },
messages: [projectedMessage('owner-start', '开始')],
});
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
await screen.findByText('chat.thinking');
act(() => mocks.events?.onTurnStart({ session_id: 'session-new' }));
if (activityEnabled) {
act(() => mocks.events?.onMessageNew({
...projectedMessage('script-step', 'vibe computer run'),
author: 'agent', source: 'agent', type: 'assistant',
created_at: '2026-08-15T00:00:10Z',
}));
expect(screen.getByText('vibe computer run')).toBeTruthy();
}
act(() => mocks.events?.onMessageNew(prompt));
const row = document.querySelector('[data-message-id="confirm-prompt"]');
expect(row).not.toBeNull();
expect(row!.textContent).toContain(prompt.text);
// The Agent's bubble, not the gold notify pill.
expect(row!.querySelector('.border-mint\\/25')).not.toBeNull();
expect(row!.textContent).not.toContain('chat.notifyLabel');
// It does not end the Turn: the running indicator stays and Stop stays live.
if (activityEnabled) expect(screen.getByText('vibe computer run')).toBeTruthy();
else expect(screen.getByText('chat.thinking')).toBeTruthy();
expect(mocks.composer?.busy).toBe(true);
// Any other notification keeps its compact status pill.
act(() => mocks.events?.onMessageNew({
...prompt, id: 'runtime-notice', text: 'runtime status', created_at: '2026-08-15T00:00:40Z', metadata: {},
}));
const notice = document.querySelector('[data-message-id="runtime-notice"]');
expect(notice!.textContent).toContain('chat.notifyLabel');
expect(notice!.querySelector('.border-mint\\/25')).toBeNull();
});
});
it('does not render an open activity group as interrupted before the switched chat turn state is known', async () => {
const openGroup = {
id: 'open-turn',
anchor_message_id: null,
anchor_position: 'after' as const,
open: true,
status: 'interrupted' as const,
steps: 1,
duration_ms: null,
};
const runningBootstrap = deferred<ReturnType<typeof bootstrapPayload>>();
const unknownActivity = deferred<{ groups: typeof openGroup[] }>();
const runningActivity = deferred<{ groups: typeof openGroup[] }>();
mocks.api.getSession.mockResolvedValue({ id: 'session-running' });
mocks.api.getSessionBootstrap
.mockReset()
.mockResolvedValueOnce({
...bootstrapPayload('session-old'),
config: { ui: { show_agent_activity: true } },
})
.mockReturnValueOnce(runningBootstrap.promise);
let runningActivityReads = 0;
mocks.api.getSessionActivity.mockImplementation((sessionId: string) => {
if (sessionId !== 'session-running') return Promise.resolve({ groups: [] });
runningActivityReads += 1;
return runningActivityReads === 1 ? unknownActivity.promise : runningActivity.promise;
});
mocks.api.getSessionActivityGroup.mockResolvedValue({
...openGroup,
rows: [{
id: 'active-step',
kind: 'assistant',
text: 'still working',
created_at: '2026-08-21T00:00:00Z',
}],
});
render(
<MemoryRouter initialEntries={['/chat/session-old']}>
<SessionSwitcher />
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
await waitFor(() => expect(mocks.api.getSessionActivity).toHaveBeenCalledWith('session-old'));
act(() => screen.getByRole('button', { name: 'switch chat' }).click());
await waitFor(() => expect(mocks.api.getSessionBootstrap).toHaveBeenCalledTimes(2));
act(() => mocks.events?.onConnected());
await waitFor(() => expect(mocks.api.getSessionActivity).toHaveBeenCalledWith('session-running'));
await act(async () => runningBootstrap.resolve({
...bootstrapPayload('session-running'),
config: { ui: { show_agent_activity: true } },
turn_state: { ...idleTurnState, foreground: 'running', in_flight: true },
}));
await act(async () => unknownActivity.resolve({ groups: [openGroup] }));
await waitFor(() => expect(runningActivityReads).toBe(2));
expect(screen.queryByText('chat.agentActivity.interrupted')).toBeNull();
await act(async () => runningActivity.resolve({ groups: [openGroup] }));
await waitFor(() => expect(screen.getByText('chat.agentActivity.running')).toBeTruthy());
expect(screen.queryByText('chat.agentActivity.interrupted')).toBeNull();
act(() => mocks.events?.onMessageNew({
...projectedMessage('next-active-step', 'next live step'),
session_id: 'session-running',
author: 'agent',
type: 'assistant',
source: 'agent',
}));
expect(screen.getByText('still working')).toBeTruthy();
expect(screen.getByText('next live step')).toBeTruthy();
});
it.each(['before summary', 'during detail'] as const)(
'retains the full running history when live rows arrive %s on a session switch',
async (arrival) => {
const rows = Array.from({ length: 300 }, (_, index) => ({
id: `step-${index}`,
kind: 'assistant' as const,
text: `activity step ${index}`,
created_at: new Date(Date.UTC(2026, 8, 5, 0, 0, index)).toISOString(),
}));
const openGroup: TurnActivityGroupWire = {
id: rows[0].id,
anchor_message_id: null,
anchor_position: 'after',
open: true,
status: 'interrupted',
steps: rows.length,
duration_ms: null,
};
const summary = deferred<{ groups: TurnActivityGroupWire[] }>();
const detail = deferred<TurnActivityGroupWire>();
const running = { ...idleTurnState, foreground: 'running', in_flight: true };
mocks.api.getSession.mockImplementation((id: string) => Promise.resolve({ id }));
mocks.api.getSessionBootstrap.mockImplementation((id: string) => Promise.resolve({
...bootstrapPayload(id),
config: { ui: { show_agent_activity: true } },
turn_state: id === 'session-running' ? running : idleTurnState,
}));
mocks.api.getTurnState.mockResolvedValue(running);
mocks.api.getSessionActivity.mockImplementation((id: string) => (
id === 'session-running' ? summary.promise : Promise.resolve({ groups: [] })
));
mocks.api.getSessionActivityGroup.mockReturnValue(detail.promise);
render(
<MemoryRouter initialEntries={['/chat/session-old']}>
<SessionSwitcher />
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
await waitFor(() => expect(mocks.api.getSessionActivity).toHaveBeenCalledWith('session-old'));
act(() => screen.getByRole('button', { name: 'switch chat' }).click());
await waitFor(() => expect(mocks.api.getSessionActivity).toHaveBeenCalledWith('session-running'));
if (arrival === 'during detail') {
await act(async () => summary.resolve({ groups: [openGroup] }));
await waitFor(() => expect(mocks.api.getSessionActivityGroup).toHaveBeenCalled());
}
const emit = (id: string, text: string) => mocks.events?.onMessageNew({
...projectedMessage(id, text),
session_id: 'session-running',
created_at: rows.find((row) => row.id === id)?.created_at
?? new Date(Date.UTC(2026, 8, 5, 0, 0, 300)).toISOString(),
author: 'agent',
type: 'assistant',
source: 'agent',
});
act(() => {
emit(rows[299].id, rows[299].text);
emit('step-300', 'activity step 300');
});
if (arrival === 'before summary') {
await act(async () => summary.resolve({ groups: [openGroup] }));
await waitFor(() => expect(mocks.api.getSessionActivityGroup).toHaveBeenCalled());
}
await act(async () => detail.resolve({ ...openGroup, rows }));
const expected = [...rows.map((row) => row.text), 'activity step 300'];
const renderedRows = () => screen.getAllByText(/^activity step \d+$/).map((el) => el.textContent);
await waitFor(() => expect(renderedRows()).toEqual(expected));
act(() => emit(rows[298].id, rows[298].text));
expect(renderedRows()).toEqual(expected);
// Reconnect can re-read an older snapshot while the live tail is newer.
const reads = mocks.api.getSessionActivityGroup.mock.calls.length;
act(() => mocks.events?.onConnected());
await waitFor(() => expect(mocks.api.getSessionActivityGroup.mock.calls.length).toBeGreaterThan(reads));
expect(renderedRows()).toEqual(expected);
},
);
it.each(['next turn', 'other session', 'same session again'] as const)(
'rejects old running history after entering the %s',
async (transition) => {
const openGroup: TurnActivityGroupWire = {
id: 'old-group', anchor_message_id: null, anchor_position: 'after',
open: true, status: 'interrupted', steps: 1, duration_ms: null,
};
const oldDetail = deferred<TurnActivityGroupWire>();
const currentDetail = deferred<TurnActivityGroupWire>();
const running = { ...idleTurnState, foreground: 'running', in_flight: true };
mocks.api.getSession.mockImplementation((id: string) => Promise.resolve({ id }));
mocks.api.getSessionBootstrap.mockImplementation((id: string) => Promise.resolve({
...bootstrapPayload(id),
config: { ui: { show_agent_activity: true } },
turn_state: running,
}));
mocks.api.getTurnState.mockResolvedValue(running);
mocks.api.getSessionActivity
.mockResolvedValueOnce({ groups: [openGroup] })
.mockResolvedValue({ groups: [{ ...openGroup, id: 'current-group' }] });
mocks.api.getSessionActivityGroup.mockImplementation((_sid: string, groupId: string) => (
groupId === 'old-group' ? oldDetail.promise : currentDetail.promise
));
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<SessionSwitcher />
<SessionSwitcher sessionId="session-new" label="return chat" />
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
await waitFor(() => expect(mocks.api.getSessionActivityGroup).toHaveBeenCalledWith('session-new', 'old-group'));
if (transition === 'next turn') {
act(() => mocks.events?.onTurnStart({ session_id: 'session-new' }));
} else {
act(() => screen.getByRole('button', { name: 'switch chat' }).click());
await waitFor(() => expect(mocks.api.getSessionBootstrap).toHaveBeenCalledTimes(2));
if (transition === 'same session again') {
act(() => screen.getByRole('button', { name: 'return chat' }).click());
await waitFor(() => expect(mocks.api.getSessionBootstrap).toHaveBeenCalledTimes(3));
}
}
act(() => mocks.events?.onMessageNew({
...projectedMessage('current-row', 'current live row'),
session_id: transition === 'other session' ? 'session-running' : 'session-new',
author: 'agent', type: 'assistant', source: 'agent',
}));
await act(async () => oldDetail.resolve({
...openGroup,
rows: [{ id: 'old-row', kind: 'assistant', text: 'obsolete history row', created_at: '2026-09-05T00:00:00Z' }],
}));
expect(screen.queryByText('obsolete history row')).toBeNull();
expect(screen.getByText('current live row')).toBeTruthy();
},
);
it('recovers running history after a detail failure while live rows continue', async () => {
const group: TurnActivityGroupWire = {
id: 'history', anchor_message_id: null, anchor_position: 'after',
open: true, status: 'interrupted', steps: 1, duration_ms: null,
};
mocks.api.getSessionBootstrap.mockResolvedValue({
...bootstrapPayload('session-new'),
config: { ui: { show_agent_activity: true } },
turn_state: { ...idleTurnState, foreground: 'running', in_flight: true },
});
mocks.api.getSessionActivity.mockResolvedValue({ groups: [group] });
mocks.api.getSessionActivityGroup
.mockRejectedValueOnce(new Error('temporary detail failure'))
.mockResolvedValue({
...group,
rows: [{ id: 'history', kind: 'assistant', text: 'recovered history row', created_at: '2026-09-05T00:00:00Z' }],
});
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
await waitFor(() => expect(mocks.api.getSessionActivityGroup).toHaveBeenCalledTimes(1));
act(() => mocks.events?.onMessageNew({
...projectedMessage('live', 'live during recovery'),
author: 'agent', type: 'assistant', source: 'agent',
}));
await waitFor(() => expect(screen.getByText('recovered history row')).toBeTruthy(), { timeout: 2500 });
expect(screen.getByText('live during recovery')).toBeTruthy();
expect(mocks.api.getSessionActivityGroup).toHaveBeenCalledTimes(2);
});
it.each((['before summary', 'during detail', 'after hydration'] as const).flatMap((arrival) => (
(['live tail', 'search history', 'capped tail'] as const).map((view) => ({ arrival, view }))
)))(
'isolates Activity phases when output arrives $arrival in $view without ending the Turn',
async ({ arrival, view }) => {
// No browser layout in jsdom; reader placement is driven explicitly below.
vi.stubGlobal('requestAnimationFrame', () => 0);
const previous: TurnActivityGroupWire = {
id: 'previous-phase', anchor_message_id: null, anchor_position: 'after',
open: true, status: 'interrupted', steps: 1, duration_ms: null,
};
const settled: TurnActivityGroupWire = {
...previous, open: false, status: 'done',
anchor_message_id: 'phase-output', anchor_position: 'before',
};
const current: TurnActivityGroupWire = {
...previous, id: 'current-phase', anchor_message_id: 'phase-output',
};
const oldSummary = deferred<{ groups: TurnActivityGroupWire[] }>();
const oldDetail = deferred<TurnActivityGroupWire>();
let phaseAdvanced = false;
const previousRow = {
id: previous.id, kind: 'assistant' as const, text: 'previous phase step',
created_at: '2026-09-05T00:00:00Z',
};
const running = { ...idleTurnState, foreground: 'running', in_flight: true };
const transcript = Array.from({ length: view === 'capped tail' ? 300 : 1 }, (_, index) => ({
...projectedMessage(`prompt-${index}`, `prompt ${index}`),
projection: undefined,
}));
const output = {
...projectedMessage('phase-output', 'phase result'),
author: 'agent', type: 'output', source: 'agent', created_at: '2026-09-05T00:00:01Z',
};
mocks.api.getSessionBootstrap.mockResolvedValue({
...bootstrapPayload('session-new'),
messages: transcript,
config: { ui: { show_agent_activity: true } }, turn_state: running,
});
mocks.api.getTurnState.mockResolvedValue(running);
mocks.api.listSessionMessages.mockImplementation((_sid: string, options?: { aroundId?: string }) => (
Promise.resolve(options?.aroundId ? {
messages: [{ ...projectedMessage('historical-prompt', 'historical prompt'), projection: undefined }],
next_after_id: 'historical-prompt',
} : { messages: [transcript[0], output] })
));
mocks.api.getSessionActivity.mockImplementation(() => (
phaseAdvanced ? Promise.resolve({ groups: [settled, current] }) : oldSummary.promise
));
mocks.api.getSessionActivityGroup.mockImplementation((_sid: string, groupId: string) => (
groupId === previous.id ? oldDetail.promise : Promise.resolve({
...current,
rows: [{ id: current.id, kind: 'assistant', text: 'current phase history', created_at: '2026-09-05T00:00:02Z' }],
})
));
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<SessionSwitcher sessionId="session-new" search="?msg=historical-prompt" label="read history" />
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
await waitFor(() => expect(mocks.api.getSessionActivity).toHaveBeenCalled());
if (arrival !== 'before summary') {
await act(async () => oldSummary.resolve({ groups: [previous] }));
await waitFor(() => expect(mocks.api.getSessionActivityGroup).toHaveBeenCalledWith('session-new', previous.id));
}
if (arrival === 'after hydration') {
await act(async () => oldDetail.resolve({ ...previous, rows: [previousRow] }));
await screen.findByText(previousRow.text);
}
if (view === 'search history') {
act(() => screen.getByRole('button', { name: 'read history' }).click());
await screen.findByText('historical prompt');
} else if (view === 'capped tail') {
// Enter through the real scroll handler; the boundary itself will detach
// the capped transcript rather than append an unseen tail message.
const scrollRoot = screen.getByTestId('chat-transcript');
Object.defineProperties(scrollRoot, {
scrollHeight: { value: 10_000, configurable: true },
clientHeight: { value: 800, configurable: true },
scrollTop: { value: 0, writable: true, configurable: true },
});
fireEvent.scroll(scrollRoot);
}
phaseAdvanced = true;
act(() => {
mocks.events?.onMessageNew(output);
});
if (view !== 'live tail') {
expect(screen.queryByText(output.text)).toBeNull();
act(() => screen.getByRole('button', { name: 'chat.scrollToBottom' }).click());
await screen.findByText(output.text);
}
act(() => {
mocks.events?.onMessageNew({
...projectedMessage('current-live', 'current phase live step'),
author: 'agent', type: 'assistant', source: 'agent', created_at: '2026-09-05T00:00:03Z',
});
});
await act(async () => {
oldSummary.resolve({ groups: [previous] });
oldDetail.resolve({ ...previous, rows: [previousRow] });
});
await screen.findByText('current phase history');
expect(screen.getByText('current phase live step')).toBeTruthy();
expect(screen.getByText('chat.agentActivity.running')).toBeTruthy();
expect(screen.queryByText(previousRow.text)).toBeNull();
// The old phase remains available only in its durable, settled chip.
act(() => screen.getByTitle('chat.agentActivity.expand').click());
await screen.findByText(previousRow.text);
expect(screen.getAllByText(previousRow.text)).toHaveLength(1);
expect(screen.getByText('current phase live step')).toBeTruthy();
},
);
it('keeps completed Activity history lazy and separate from the running card', async () => {
const group: TurnActivityGroupWire = {
id: 'completed', anchor_message_id: null, anchor_position: 'before',
open: false, status: 'done', steps: 1, duration_ms: 1000,
};
mocks.api.getSessionBootstrap.mockResolvedValue({
...bootstrapPayload('session-new'),
config: { ui: { show_agent_activity: true } },
messages: [projectedMessage('user-message', 'start completed task')],
});
mocks.api.getSessionActivity.mockResolvedValue({ groups: [group] });
mocks.api.getSessionActivityGroup.mockResolvedValue({
...group,
rows: [{ id: 'completed', kind: 'assistant', text: 'completed history row', created_at: '2026-09-05T00:00:00Z' }],
});
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
const expand = await screen.findByTitle('chat.agentActivity.expand');
expect(mocks.api.getSessionActivityGroup).not.toHaveBeenCalled();
act(() => expand.click());
await screen.findByText('completed history row');
expect(screen.queryByText('chat.agentActivity.running')).toBeNull();
});
it('uses the thinking dots and the Activity header as shortcuts for the global display setting', async () => {
const openGroup = {
id: 'current-turn',
anchor_message_id: null,
anchor_position: 'after' as const,
open: true,
status: 'running' as const,
steps: 1,
duration_ms: null,
};
mocks.api.getSession.mockResolvedValue({ id: 'session-new' });
mocks.api.getSessionBootstrap.mockResolvedValue({
...bootstrapPayload('session-new'),
turn_state: { ...idleTurnState, foreground: 'running', in_flight: true },
});
mocks.api.getSessionActivity.mockResolvedValue({ groups: [openGroup] });
mocks.api.getSessionActivityGroup.mockResolvedValue({
...openGroup,
rows: [{
id: 'current-step',
kind: 'assistant',
text: 'current work step',
created_at: '2026-08-25T00:00:00Z',
}],
});
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
const enable = await screen.findByRole('button', { name: 'chat.agentActivity.enable' });
expect(enable.className).toContain('cursor-pointer');
act(() => enable.click());
await waitFor(() => expect(mocks.api.mutateConfig).toHaveBeenCalledWith([
{ kind: 'set', path: ['ui', 'show_agent_activity'], value: true },
]));
await waitFor(() => expect(screen.getByText('current work step')).toBeTruthy());
const disable = screen.getByRole('button', { name: 'chat.agentActivity.disable' });
expect(disable.className).toContain('size-6');
expect(disable.className).toContain('border-border');
act(() => disable.click());
await waitFor(() => expect(mocks.api.mutateConfig).toHaveBeenCalledWith([
{ kind: 'set', path: ['ui', 'show_agent_activity'], value: false },
]));
await waitFor(() => expect(screen.queryByText('current work step')).toBeNull());
expect(screen.getByRole('button', { name: 'chat.agentActivity.enable' })).toBeTruthy();
});
it('waits for a visibility write before bootstrapping a switched chat', async () => {
const activityWrite = deferred<{ ui: { show_agent_activity: boolean } }>();
mocks.api.getSession.mockImplementation((id: string) => Promise.resolve({ id }));
mocks.api.getSessionBootstrap
.mockResolvedValueOnce({
...bootstrapPayload('session-new'),
turn_state: { ...idleTurnState, foreground: 'running', in_flight: true },
})
.mockResolvedValueOnce({
...bootstrapPayload('session-running'),
config: { ui: { show_agent_activity: true } },
turn_state: { ...idleTurnState, foreground: 'running', in_flight: true },
});
mocks.api.mutateConfig.mockImplementationOnce(() => activityWrite.promise);
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<SessionSwitcher />
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
const enable = await screen.findByRole('button', { name: 'chat.agentActivity.enable' });
mocks.api.waitForAgentActivityConfigMutations.mockImplementationOnce(
() => activityWrite.promise.then(() => undefined),
);
act(() => enable.click());
await waitFor(() => expect(mocks.api.mutateConfig).toHaveBeenCalledTimes(1));
act(() => screen.getByRole('button', { name: 'switch chat' }).click());
await act(async () => Promise.resolve());
expect(mocks.api.getSessionBootstrap).toHaveBeenCalledTimes(1);
await act(async () => activityWrite.resolve({ ui: { show_agent_activity: true } }));
await waitFor(() => expect(mocks.api.getSessionBootstrap).toHaveBeenCalledTimes(2));
expect(mocks.api.getSessionBootstrap).toHaveBeenLastCalledWith('session-running');
await waitFor(() => expect(screen.queryByRole('button', {
name: 'chat.agentActivity.enable',
})).toBeNull());
});
it('does not let an in-flight authorization bootstrap overwrite a newer visibility click', async () => {
const authorizationBootstrap = deferred<ReturnType<typeof bootstrapPayload>>();
mocks.api.getSession.mockResolvedValue({ id: 'session-new' });
mocks.api.getSessionBootstrap
.mockResolvedValueOnce({
...bootstrapPayload('session-new'),
turn_state: { ...idleTurnState, foreground: 'running', in_flight: true },
})
.mockImplementationOnce(() => authorizationBootstrap.promise);
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
const enable = await screen.findByRole('button', { name: 'chat.agentActivity.enable' });
act(() => mocks.events?.onAuthorizationChanged({ instance_authorization_revision: 2 }));
await waitFor(() => expect(mocks.api.getSessionBootstrap).toHaveBeenCalledTimes(2));
act(() => enable.click());
await waitFor(() => expect(mocks.api.mutateConfig).toHaveBeenCalledTimes(1));
await act(async () => authorizationBootstrap.resolve({
...bootstrapPayload('session-new'),
turn_state: { ...idleTurnState, foreground: 'running', in_flight: true },
}));
await waitFor(() => expect(screen.queryByRole('button', {
name: 'chat.agentActivity.enable',
})).toBeNull());
});
it('restores the enable shortcut when the visibility write fails', async () => {
mocks.api.getSession.mockResolvedValue({ id: 'session-new' });
mocks.api.getSessionBootstrap.mockResolvedValue({
...bootstrapPayload('session-new'),
turn_state: { ...idleTurnState, foreground: 'running', in_flight: true },
});
mocks.api.mutateConfig.mockRejectedValueOnce(new Error('save failed'));
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
const enable = await screen.findByRole('button', { name: 'chat.agentActivity.enable' });
act(() => enable.click());
await waitFor(() => expect(mocks.api.mutateConfig).toHaveBeenCalledTimes(1));
await waitFor(() => expect(screen.getByRole('button', {
name: 'chat.agentActivity.enable',
})).toBeTruthy());
});
it('restores the last confirmed visibility when the latest write fails', async () => {
const openGroup = {
id: 'current-turn',
anchor_message_id: null,
anchor_position: 'after' as const,
open: true,
status: 'running' as const,
steps: 1,
duration_ms: null,
};
mocks.api.getSession.mockResolvedValue({ id: 'session-new' });
mocks.api.getSessionBootstrap.mockResolvedValue({
...bootstrapPayload('session-new'),
turn_state: { ...idleTurnState, foreground: 'running', in_flight: true },
});
mocks.api.getSessionActivity.mockResolvedValue({ groups: [openGroup] });
mocks.api.getSessionActivityGroup.mockResolvedValue({
...openGroup,
rows: [{
id: 'current-step',
kind: 'assistant',
text: 'current work step',
created_at: '2026-08-25T00:00:00Z',
}],
});
mocks.api.mutateConfig
.mockResolvedValueOnce({ ui: { show_agent_activity: true } })
.mockRejectedValueOnce(new Error('save failed'));
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
const enable = await screen.findByRole('button', { name: 'chat.agentActivity.enable' });
act(() => enable.click());
await screen.findByText('current work step');
const disable = screen.getByRole('button', { name: 'chat.agentActivity.disable' });
act(() => disable.click());
await waitFor(() => expect(mocks.api.mutateConfig).toHaveBeenCalledTimes(2));
await screen.findByText('current work step');
await waitFor(() => expect(screen.getByRole('button', {
name: 'chat.agentActivity.disable',
})).toBeTruthy());
});
it('does not offer the global enable shortcut to a Viewer', async () => {
mocks.authorizationCapabilities.can_chat = false;
mocks.api.getSession.mockResolvedValue({ id: 'session-new' });
mocks.api.getSessionBootstrap.mockResolvedValue({
...bootstrapPayload('session-new'),
turn_state: { ...idleTurnState, foreground: 'running', in_flight: true },
});
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
await screen.findByText('chat.thinking');
expect(screen.queryByRole('button', { name: 'chat.agentActivity.enable' })).toBeNull();
expect(mocks.api.mutateConfig).not.toHaveBeenCalled();
});
it('does not offer the global disable shortcut to a Viewer', async () => {
mocks.authorizationCapabilities.can_chat = false;
const openGroup = {
id: 'current-turn',
anchor_message_id: null,
anchor_position: 'after' as const,
open: true,
status: 'running' as const,
steps: 1,
duration_ms: null,
};
mocks.api.getSession.mockResolvedValue({ id: 'session-new' });
mocks.api.getSessionBootstrap.mockResolvedValue({
...bootstrapPayload('session-new'),
config: { ui: { show_agent_activity: true } },
turn_state: { ...idleTurnState, foreground: 'running', in_flight: true },
});
mocks.api.getSessionActivity.mockResolvedValue({ groups: [openGroup] });
mocks.api.getSessionActivityGroup.mockResolvedValue({
...openGroup,
rows: [{
id: 'current-step',
kind: 'assistant',
text: 'viewer-visible work step',
created_at: '2026-08-25T00:00:00Z',
}],
});
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes>
<Route path="/chat/:sessionId" element={<ChatPage />} />
</Routes>
</MemoryRouter>,
);
await screen.findByText('viewer-visible work step');
expect(screen.queryByRole('button', { name: 'chat.agentActivity.disable' })).toBeNull();
expect(mocks.api.mutateConfig).not.toHaveBeenCalled();
});
describe('quiet model recovery in the existing progress slots', () => {
const now = Date.parse('2026-09-09T04:00:10Z');
const recovery = (overrides: Partial<ModelRecoveryState> = {}): ModelRecoveryState => ({
request_id: 'pending-request',
phase: 'waiting',
attempt_count: 1,
started_at: new Date(now - 6000).toISOString(),
window_end: new Date(now + 114_000).toISOString(),
next_eligible_at: new Date(now + 24_000).toISOString(),
source_id: 'private-source',
reason: 'https://private-host.invalid/diagnostic',
...overrides,
});
const running = (model_recovery: ModelRecoveryState[] = [recovery()]): SessionRuntimeState => ({
...idleTurnState, in_flight: true, foreground: 'running', model_recovery,
});
const invalidate = () => mocks.events?.onSessionActivity({ session_id: 'session-new', event: 'model_recovery' });
const mount = async (state = running(), activity = false) => {
mocks.api.getSession.mockResolvedValue({ id: 'session-new' });
mocks.api.getSessionBootstrap.mockResolvedValue({
...bootstrapPayload('session-new'),
config: { ui: { show_agent_activity: activity } },
draft: { text: 'unsent draft 草稿' },
turn_state: state,
});
mocks.api.getTurnState.mockResolvedValue(state);
const view = render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<SessionSwitcher />
<SessionSwitcher sessionId="session-new" label="return chat" />
<Routes><Route path="/chat/:sessionId" element={<ChatPage />} /></Routes>
</MemoryRouter>,
);
await act(async () => Promise.resolve());
expect(screen.queryByText('common.loading')).toBeNull();
return view;
};
beforeEach(() => {
vi.useFakeTimers();
vi.setSystemTime(now);
});
it.each([false, true])('reuses the label with Activity enabled=%s, preserving controls and rows', async (activity) => {
const { container } = await mount(running([recovery({ started_at: new Date(now).toISOString() })]), activity);
if (activity) {
act(() => mocks.events?.onMessageNew({
...projectedMessage('step', 'existing tool narration'), author: 'agent', type: 'assistant', source: 'agent',
}));
}
const generic = activity ? 'chat.agentActivity.running' : 'chat.thinking';
const labelSlot = screen.getByText(generic);
const structure = container.querySelectorAll('*').length;
expect(container.querySelectorAll('[data-message-id]')).toHaveLength(0);
act(() => vi.advanceTimersByTime(4999));
expect(screen.queryByText('chat.modelRecovery.waitingSeconds')).toBeNull();
act(() => vi.advanceTimersByTime(1));
expect(screen.getByText('chat.modelRecovery.waitingSeconds')).toBe(labelSlot);
expect(container.querySelectorAll('*')).toHaveLength(structure);
expect(container.querySelectorAll('[data-message-id]')).toHaveLength(0);
expect(container.textContent).not.toMatch(/private-source|https:|2026-09|UTC/);
expect(mocks.composer?.busy).toBe(true);
expect(mocks.composer?.initialDraft).toBe('unsent draft 草稿');
if (activity) expect(screen.getByText('existing tool narration')).toBeTruthy();
else expect(container.querySelectorAll('.vr-typing-dot')).toHaveLength(3);
await act(async () => mocks.composer?.onStop?.());
expect(mocks.api.cancelSession).toHaveBeenCalledExactlyOnceWith('session-new');
expect(mocks.composer?.busy).toBe(true);
expect(screen.getByText('chat.modelRecovery.waitingSeconds')).toBeTruthy();
});
it('restores a mature snapshot immediately, follows invalidations, and clears without ending work', async () => {
await mount();
expect(screen.getAllByText('chat.modelRecovery.waitingSeconds')).toHaveLength(1);
mocks.api.getTurnState.mockResolvedValue(running([recovery({ phase: 'attempting' })]));
await act(async () => invalidate());
expect(screen.getByText('chat.modelRecovery.attempting')).toBeTruthy();
mocks.api.getTurnState.mockResolvedValue(running([]));
await act(async () => invalidate());
expect(screen.queryByText('chat.modelRecovery.attempting')).toBeNull();
expect(screen.getByText('chat.thinking')).toBeTruthy();
expect(mocks.composer?.busy).toBe(true);
expect(mocks.composer?.initialDraft).toBe('unsent draft 草稿');
});
it('keeps the mature label when the first activity row replaces the thinking bubble', async () => {
const { container } = await mount(running(), true);
expect(container.querySelectorAll('.vr-typing-dot')).toHaveLength(3);
expect(screen.getByText('chat.modelRecovery.waitingSeconds')).toBeTruthy();
act(() => mocks.events?.onMessageNew({
...projectedMessage('step', 'first activity'), author: 'agent', type: 'assistant', source: 'agent',
}));
expect(container.querySelectorAll('.vr-typing-dot')).toHaveLength(0);
expect(screen.getByText('first activity')).toBeTruthy();
expect(screen.getAllByText('chat.modelRecovery.waitingSeconds')).toHaveLength(1);
});
it('does not hide pending peer recovery when a terminal message arrives', async () => {
await mount();
act(() => mocks.events?.onMessageNew({
...projectedMessage('peer-result', 'one request finished'),
author: 'agent', type: 'result', source: 'agent',
}));
expect(screen.getByText('one request finished')).toBeTruthy();
expect(screen.getByText('chat.modelRecovery.waitingSeconds')).toBeTruthy();
expect(mocks.composer?.busy).toBe(true);
});
it('ignores other sessions and rejects an older wait after a newer clear response', async () => {
await mount();
const stale = deferred<SessionRuntimeState>();
mocks.api.getTurnState.mockReturnValueOnce(stale.promise).mockResolvedValue(running([]));
await act(async () => mocks.events?.onSessionActivity({ session_id: 'elsewhere', event: 'model_recovery' }));
expect(mocks.api.getTurnState).not.toHaveBeenCalled();
act(invalidate);
await act(async () => invalidate());
expect(screen.getByText('chat.thinking')).toBeTruthy();
await act(async () => stale.resolve(running()));
expect(screen.queryByText('chat.modelRecovery.waitingSeconds')).toBeNull();
expect(mocks.composer?.busy).toBe(true);
});
it.each(['start', 'end'] as const)('clears on turn %s and rejects an in-flight old snapshot', async (event) => {
await mount();
const stale = deferred<SessionRuntimeState>();
mocks.api.getTurnState.mockReturnValueOnce(stale.promise).mockResolvedValue(idleTurnState);
act(invalidate);
await act(async () => {
if (event === 'start') mocks.events?.onTurnStart({ session_id: 'session-new' });
else mocks.events?.onTurnEnd({ session_id: 'session-new' });
});
expect(screen.queryByText('chat.modelRecovery.waitingSeconds')).toBeNull();
await act(async () => stale.resolve(running()));
expect(screen.queryByText('chat.modelRecovery.waitingSeconds')).toBeNull();
expect(mocks.composer?.busy).toBe(event === 'start');
});
it.each(['start', 'end'] as const)('does not let a delayed bootstrap revive recovery after turn %s', async (event) => {
const stale = deferred<ReturnType<typeof bootstrapPayload>>();
mocks.api.getSession.mockResolvedValue({ id: 'session-new' });
mocks.api.getSessionBootstrap.mockReturnValue(stale.promise);
render(
<MemoryRouter initialEntries={['/chat/session-new']}>
<Routes><Route path="/chat/:sessionId" element={<ChatPage />} /></Routes>
</MemoryRouter>,
);
await act(async () => Promise.resolve());
await act(async () => {
if (event === 'start') mocks.events?.onTurnStart({ session_id: 'session-new' });
else mocks.events?.onTurnEnd({ session_id: 'session-new' });
});
await act(async () => stale.resolve({ ...bootstrapPayload('session-new'), turn_state: running() }));
expect(screen.queryByText('common.loading')).toBeNull();
expect(screen.queryByText('chat.modelRecovery.waitingSeconds')).toBeNull();
expect(mocks.composer?.busy).toBe(event === 'start');
});
it('rejects a stale response through A → B → A navigation', async () => {
await mount();
const stale = deferred<SessionRuntimeState>();
mocks.api.getTurnState.mockReturnValueOnce(stale.promise);
act(invalidate);
mocks.api.getSessionBootstrap.mockImplementation((id: string) => Promise.resolve(bootstrapPayload(id)));
await act(async () => screen.getByText('switch chat').click());
expect(screen.queryByText('chat.modelRecovery.waitingSeconds')).toBeNull();
await act(async () => screen.getByText('return chat').click());
await act(async () => stale.resolve(running()));
expect(screen.queryByText('chat.modelRecovery.waitingSeconds')).toBeNull();
expect(mocks.composer?.busy).toBe(false);
});
it('clears a dropped end from an idle snapshot while preserving unknown-state recovery', async () => {
await mount();
mocks.api.getTurnState.mockResolvedValue({ ...idleTurnState, foreground: 'unknown', in_flight: null });
await act(async () => invalidate());
expect(screen.getByText('chat.modelRecovery.waitingSeconds')).toBeTruthy();
act(() => vi.advanceTimersByTime(5000));
mocks.api.getTurnState.mockResolvedValue({ ...idleTurnState, model_recovery: [recovery()] });
await act(async () => invalidate());
expect(screen.queryByText('chat.modelRecovery.waitingSeconds')).toBeNull();
expect(mocks.composer?.busy).toBe(false);
});
it('does not let an older bootstrap revive a dropped end recovered by the idle poll', async () => {
await mount();
const stale = deferred<ReturnType<typeof bootstrapPayload>>();
mocks.api.getSessionBootstrap.mockReturnValue(stale.promise);
await act(async () => mocks.events?.onAuthorizationChanged({ resource_kinds: [] }));
act(() => vi.advanceTimersByTime(5000));
mocks.api.getTurnState.mockResolvedValue(idleTurnState);
await act(async () => invalidate());
await act(async () => stale.resolve({ ...bootstrapPayload('session-new'), turn_state: running() }));
expect(screen.queryByText('chat.modelRecovery.waitingSeconds')).toBeNull();
expect(mocks.composer?.busy).toBe(false);
});
});
});