Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

fix(cos): preserve completed cards during agent deletion

[._.]/ Adam Eivyc73d35fa9c0d
diff --git a/client/src/components/cos/tabs/AgentsTab.jsx b/client/src/components/cos/tabs/AgentsTab.jsx
index cc41b40ae4..eb395ac2b4 100644
--- a/client/src/components/cos/tabs/AgentsTab.jsx
+++ b/client/src/components/cos/tabs/AgentsTab.jsx
@@ -7,6 +7,7 @@ import AgentCard from './AgentCard';
import ResumeAgentModal from './ResumeAgentModal';
import RelaunchAgentModal from './RelaunchAgentModal';
import InfiniteScrollFooter from '../../ui/InfiniteScrollFooter';
+import useMounted from '../../../hooks/useMounted';
import { usePagedCollection } from '../../../hooks/usePagedCollection';
import { useSocketResource } from '../../../hooks/useSocketResource';
import socket from '../../../services/socket';
@@ -40,6 +41,8 @@ const FEEDBACK_EVENTS = ['cos:agent:feedback', 'cos:agent:completed'];
export default function AgentsTab({ agentsLoaded = true, agentsError = null, onRetryAgents, completedRevision = 0, agents, onRefresh, liveOutputs, providers, providersLoaded, apps }) {
const { agentId } = useParams();
+ const mounted = useMounted();
+ const [deletedIds, setDeletedIds] = useState(() => new Set());
const [focusedAgent, setFocusedAgent] = useState(null);
const [focusLoading, setFocusLoading] = useState(false);
useEffect(() => {
@@ -108,10 +111,14 @@ export default function AgentsTab({ agentsLoaded = true, agentsError = null, onR
const handleDelete = useCallback(async (agentId) => {
const result = await api.deleteCosAgent(agentId, { silent: true }).catch(err => { toast.error(err.message); return null; });
- if (!result) return;
+ if (!result || !mounted.current) return;
+ // Keep the loaded history and card instances intact. Remember confirmed
+ // removals across stale parent snapshots and delayed focused-agent reads.
+ setDeletedIds(previous => new Set([...previous, agentId]));
+ history.removeItem(agentId);
+ pendingFeedback.refetch();
toast.success('Agent removed');
- refresh();
- }, [refresh]);
+ }, [history.removeItem, pendingFeedback.refetch, mounted]);
// ResumeAgentModal builds a NEW task prompt out of `metadata.taskDescription`,
// and the listing carries a bounded copy of it (server/lib/cosAgentListProjection.js).
@@ -186,8 +193,8 @@ export default function AgentsTab({ agentsLoaded = true, agentsError = null, onR
};
// Running agents come from props (real-time via parent socket updates)
- const runningAgents = agents.filter(a => a.status === 'running');
- const pausedAgents = agents.filter(a => a.status === 'paused');
+ const runningAgents = agents.filter(a => a.status === 'running' && !deletedIds.has(a.id));
+ const pausedAgents = agents.filter(a => a.status === 'paused' && !deletedIds.has(a.id));
// Completed agents still in state (recently completed, not yet archived)
const recentCompleted = agents.filter(a => a.status === 'completed');
// Merge recent completed (from state) with loaded (from disk), deduplicate
@@ -195,7 +202,7 @@ export default function AgentsTab({ agentsLoaded = true, agentsError = null, onR
const seen = new Set();
const merged = [];
const addAgent = (agent) => {
- if (seen.has(agent.id)) return;
+ if (seen.has(agent.id) || deletedIds.has(agent.id)) return;
seen.add(agent.id);
const feedback = feedbackUpdates[agent.id];
merged.push(feedback ? { ...agent, feedback } : agent);
@@ -206,7 +213,7 @@ export default function AgentsTab({ agentsLoaded = true, agentsError = null, onR
for (const agent of loadedAgents) addAgent(agent);
return merged.sort((a, b) => new Date(b.completedAt || 0) - new Date(a.completedAt || 0));
- }, [recentCompleted, loadedAgents, feedbackUpdates]);
+ }, [recentCompleted, loadedAgents, feedbackUpdates, deletedIds]);
const totalCount = history.total ?? allCompleted.length;
@@ -236,7 +243,8 @@ export default function AgentsTab({ agentsLoaded = true, agentsError = null, onR
? locallyVisibleNeedsFeedback
: Math.max(pendingFeedbackCount, locallyVisibleNeedsFeedback);
- const selectedRecord = agents.find(agent => agent.id === agentId) || (focusedAgent?.id === agentId ? focusedAgent : null);
+ const selectedRecord = deletedIds.has(agentId) ? null
+ : agents.find(agent => agent.id === agentId) || (focusedAgent?.id === agentId ? focusedAgent : null);
const selectedAgent = selectedRecord && feedbackUpdates[agentId]
? { ...selectedRecord, feedback: feedbackUpdates[agentId] } : selectedRecord;
diff --git a/client/src/components/cos/tabs/AgentsTab.test.jsx b/client/src/components/cos/tabs/AgentsTab.test.jsx
index 30c128f967..049ad614f9 100644
--- a/client/src/components/cos/tabs/AgentsTab.test.jsx
+++ b/client/src/components/cos/tabs/AgentsTab.test.jsx
@@ -26,6 +26,7 @@ vi.mock('../../../services/api', () => ({
getCosPendingAgentFeedback: vi.fn(),
hydrateCosAgentDescription: vi.fn(async (agent) => agent),
clearCompletedCosAgents: vi.fn(),
+ deleteCosAgent: vi.fn(),
resumeCosAgent: vi.fn(),
relaunchCosAgent: vi.fn(),
addCosTask: vi.fn(),
@@ -36,9 +37,11 @@ vi.mock('../../ui/Toast', () => ({
}));
vi.mock('./AgentCard', () => ({
- default: ({ agent, onFeedbackChange, onResume, onRelaunch }) => (
+ default: ({ agent, onFeedbackChange, onResume, onRelaunch, onDelete }) => (
<div data-testid={`agent-${agent.id}`}>
<span>{agent.metadata?.taskDescription}</span>
+ {onDelete && <button type="button" onClick={() => onDelete(agent.id)}>Delete {agent.id}</button>}
+ <input aria-label={`Card draft ${agent.id}`} defaultValue="" />
{onResume && (
<button type="button" onClick={() => onResume(agent)}>Resume {agent.id}</button>
)}
@@ -485,3 +488,163 @@ it('makes the clear scope explicit when the feedback filter hides completed reco
expect(screen.getByText(/including records outside the current filter and unloaded pages/)).toBeInTheDocument();
expect(screen.queryByText(/removes 1 agent record/)).not.toBeInTheDocument();
});
+
+
+const deferred = () => {
+ let resolve;
+ let reject;
+ const promise = new Promise((res, rej) => { resolve = res; reject = rej; });
+ return { promise, resolve, reject };
+};
+
+describe('AgentsTab confirmed deletion', () => {
+ it('retains other card instances, search, filter and loaded pages without a list reload', async () => {
+ const user = userEvent.setup();
+ const first = completedAgent('first', 'Shared first');
+ const second = completedAgent('second', 'Shared second');
+ const older = completedAgent('older', 'Shared older');
+ api.getCosCompletedAgents
+ .mockResolvedValueOnce({ items: [first, second], total: 4, nextCursor: 'second-cursor' })
+ .mockResolvedValueOnce({ items: [older], total: 4, nextCursor: 'older-cursor' })
+ .mockResolvedValueOnce({ items: [second], total: 3, nextCursor: 'second-cursor' })
+ .mockResolvedValueOnce({ items: [completedAgent('oldest', 'Shared oldest')], total: 3, nextCursor: null });
+ const deletion = deferred();
+ api.deleteCosAgent.mockReturnValue(deletion.promise);
+ const onRefresh = vi.fn();
+ renderTab([], onRefresh, '/cos/agents?feedback=needs-feedback');
+ await screen.findByTestId('agent-second');
+ await user.click(screen.getByRole('button', { name: 'Load older agents' }));
+ const olderCard = await screen.findByTestId('agent-older');
+ const secondCard = screen.getByTestId('agent-second');
+ const grid = olderCard.parentElement;
+ grid.scrollTop = 240;
+ await user.type(screen.getByRole('textbox', { name: 'Card draft second' }), 'Keep local state');
+ await user.type(screen.getByRole('textbox', { name: 'Search completed agents' }), 'Shared');
+ await user.click(screen.getByRole('button', { name: 'Delete first' }));
+ expect(screen.getByTestId('agent-first')).toBeInTheDocument();
+ await act(async () => deletion.resolve({ success: true, agentId: 'first' }));
+ expect(screen.queryByTestId('agent-first')).toBeNull();
+ expect(screen.getByTestId('agent-second')).toBe(secondCard);
+ expect(screen.getByTestId('agent-older')).toBe(olderCard);
+ expect(screen.getByRole('textbox', { name: 'Card draft second' })).toHaveValue('Keep local state');
+ expect(screen.getByRole('textbox', { name: 'Search completed agents' })).toHaveValue('Shared');
+ expect(screen.getByRole('button', { name: /Needs feedback:/ })).toHaveAttribute('aria-pressed', 'true');
+ expect(grid.scrollTop).toBe(240);
+ expect(screen.getByText('(3 total)')).toBeInTheDocument();
+ expect(api.getCosCompletedAgents).toHaveBeenCalledTimes(3);
+ expect(onRefresh).not.toHaveBeenCalled();
+ await user.click(screen.getByRole('button', { name: 'Load older agents' }));
+ expect(api.getCosCompletedAgents).toHaveBeenLastCalledWith(expect.objectContaining({ cursor: 'older-cursor', feedback: true }));
+ });
+
+ it('removes only each confirmed ID when deletes settle out of order and parent props stay stale', async () => {
+ const user = userEvent.setup();
+ const first = completedAgent('first', 'First');
+ const second = completedAgent('second', 'Second');
+ const survivor = completedAgent('survivor', 'Survivor');
+ api.getCosCompletedAgents.mockResolvedValue({ items: [first, second, survivor], total: 3, nextCursor: null });
+ const firstDelete = deferred();
+ const secondDelete = deferred();
+ api.deleteCosAgent.mockImplementation(id => id === 'first' ? firstDelete.promise : secondDelete.promise);
+ renderTab([first, second]);
+ const survivorCard = await screen.findByTestId('agent-survivor');
+ await user.click(screen.getByRole('button', { name: 'Delete first' }));
+ await user.click(screen.getByRole('button', { name: 'Delete second' }));
+ api.getCosCompletedAgents.mockResolvedValue({ items: [first, survivor], total: 2, nextCursor: null });
+ await act(async () => secondDelete.resolve({ success: true, agentId: 'second' }));
+ expect(screen.queryByTestId('agent-second')).toBeNull();
+ expect(screen.getByTestId('agent-first')).toBeInTheDocument();
+ expect(screen.getByText('(2 total)')).toBeInTheDocument();
+ api.getCosCompletedAgents.mockResolvedValue({ items: [survivor], total: 1, nextCursor: null });
+ await act(async () => {
+ socket.receive('cos:agent:feedback', { agentId: 'second', feedback: { rating: 'positive' } });
+ firstDelete.resolve({ success: true, agentId: 'first' });
+ });
+ expect(screen.queryByTestId('agent-first')).toBeNull();
+ expect(screen.queryByTestId('agent-second')).toBeNull();
+ expect(screen.getByTestId('agent-survivor')).toBe(survivorCard);
+ expect(screen.getByText('(1 total)')).toBeInTheDocument();
+ });
+
+ it('keeps every card and local state when deletion fails', async () => {
+ const user = userEvent.setup();
+ api.getCosCompletedAgents.mockResolvedValue({ items: [completedAgent('first', 'First')], total: 1, nextCursor: null });
+ api.deleteCosAgent.mockRejectedValue(new Error('Could not remove agent'));
+ const onRefresh = vi.fn();
+ renderTab([], onRefresh);
+ const card = await screen.findByTestId('agent-first');
+ await user.type(screen.getByRole('textbox', { name: 'Card draft first' }), 'Keep me');
+ await user.click(screen.getByRole('button', { name: 'Delete first' }));
+ expect(toast.error).toHaveBeenCalledWith('Could not remove agent');
+ expect(screen.getByTestId('agent-first')).toBe(card);
+ expect(screen.getByRole('textbox', { name: 'Card draft first' })).toHaveValue('Keep me');
+ expect(screen.getByText('(1 total)')).toBeInTheDocument();
+ expect(api.getCosCompletedAgents).toHaveBeenCalledTimes(1);
+ expect(onRefresh).not.toHaveBeenCalled();
+ });
+});
+
+
+describe('AgentsTab deletion reconciliation races', () => {
+ it('uses the server count when a completion refresh observes deletion before DELETE returns', async () => {
+ const user = userEvent.setup();
+ const removed = completedAgent('removed', 'Removed');
+ const kept = completedAgent('kept', 'Kept');
+ const deletion = deferred();
+ api.deleteCosAgent.mockReturnValue(deletion.promise);
+ api.getCosCompletedAgents.mockResolvedValueOnce({ items: [removed, kept], total: 2, nextCursor: null })
+ .mockResolvedValue({ items: [kept], total: 1, nextCursor: null });
+ const tab = revision => <MemoryRouter><AgentsTab agents={[]} onRefresh={vi.fn()} liveOutputs={{}}
+ providers={[]} apps={[]} completedRevision={revision} /></MemoryRouter>;
+ const view = render(tab(0));
+ const keptCard = await screen.findByTestId('agent-kept');
+ await user.click(screen.getByRole('button', { name: 'Delete removed' }));
+ view.rerender(tab(1));
+ await waitFor(() => expect(screen.getByText('(1 total)')).toBeInTheDocument());
+ // The additive refresh retains loaded rows; the DELETE hasn't acknowledged yet.
+ expect(screen.getByTestId('agent-removed')).toBeInTheDocument();
+ await act(async () => deletion.resolve({ success: true, agentId: 'removed' }));
+ expect(screen.queryByTestId('agent-removed')).toBeNull();
+ expect(screen.getByText('(1 total)')).toBeInTheDocument();
+ expect(screen.getByTestId('agent-kept')).toBe(keptCard);
+ });
+
+ it('reconciles counts when deleting a selected record outside loaded history', async () => {
+ const user = userEvent.setup();
+ const selected = completedAgent('selected', 'Selected');
+ const kept = completedAgent('kept', 'Kept');
+ api.getCosAgent.mockResolvedValue(selected);
+ api.getCosCompletedAgents.mockResolvedValueOnce({ items: [kept], total: 2, nextCursor: 'kept' })
+ .mockResolvedValue({ items: [kept], total: 1, nextCursor: null });
+ api.deleteCosAgent.mockResolvedValue({ success: true, agentId: 'selected' });
+ render(<MemoryRouter initialEntries={['/cos/agents/selected']}><Routes>
+ <Route path="/cos/agents/:agentId" element={<AgentsTab agents={[]} onRefresh={vi.fn()}
+ liveOutputs={{}} providers={[]} apps={[]} />} />
+ </Routes></MemoryRouter>);
+ await screen.findByTestId('agent-selected');
+ const keptCard = await screen.findByTestId('agent-kept');
+ await user.click(screen.getByRole('button', { name: 'Delete selected' }));
+ expect(screen.queryByTestId('agent-selected')).toBeNull();
+ expect(screen.getByText('(1 total)')).toBeInTheDocument();
+ expect(screen.getByTestId('agent-kept')).toBe(keptCard);
+ });
+
+ it('does not restore a deleted card when its focused detail read resolves late', async () => {
+ const user = userEvent.setup();
+ const selected = completedAgent('selected', 'Selected');
+ const focus = deferred();
+ api.getCosAgent.mockReturnValue(focus.promise);
+ api.getCosCompletedAgents.mockResolvedValueOnce({ items: [selected], total: 1, nextCursor: null })
+ .mockResolvedValue({ items: [], total: 0, nextCursor: null });
+ api.deleteCosAgent.mockResolvedValue({ success: true, agentId: 'selected' });
+ render(<MemoryRouter initialEntries={['/cos/agents/selected']}><Routes>
+ <Route path="/cos/agents/:agentId" element={<AgentsTab agents={[]} onRefresh={vi.fn()}
+ liveOutputs={{}} providers={[]} apps={[]} />} />
+ </Routes></MemoryRouter>);
+ await screen.findByTestId('agent-selected');
+ await user.click(screen.getByRole('button', { name: 'Delete selected' }));
+ await act(async () => focus.resolve(selected));
+ expect(screen.queryByTestId('agent-selected')).toBeNull();
+ expect(screen.getByText('Agent not found or unavailable.')).toBeInTheDocument();
+ });
+});
diff --git a/client/src/hooks/usePagedCollection.js b/client/src/hooks/usePagedCollection.js
index f473d5562c..9f5a3f9895 100644
--- a/client/src/hooks/usePagedCollection.js
+++ b/client/src/hooks/usePagedCollection.js
@@ -11,6 +11,8 @@ export function usePagedCollection(fetchPage, { enabled = true } = {}) {
const state = useRef(page);
const generation = useRef(0);
const pending = useRef(null);
+ const restartPending = useRef(null);
+ const currentRead = useRef(null);
const refreshQueued = useRef(false);
const retryRefresh = useRef(false);
const commit = useCallback(next => { state.current = next; setPage(next); }, []);
@@ -21,6 +23,7 @@ export function usePagedCollection(fetchPage, { enabled = true } = {}) {
const epoch = generation.current;
const controller = new AbortController();
pending.current = controller;
+ restartPending.current = () => readPage(refresh);
commit({ ...state.current, loading: true, error: null });
try {
const result = await fetchPage({ cursor: refresh ? null : state.current.nextCursor, signal: controller.signal });
@@ -49,6 +52,8 @@ export function usePagedCollection(fetchPage, { enabled = true } = {}) {
}
}, [enabled, fetchPage, commit]);
+ useEffect(() => { currentRead.current = read; }, [read]);
+
const loadMore = useCallback(() => read(Boolean(state.current.error && retryRefresh.current)), [read]);
const refreshFirst = useCallback(() => read(true), [read]);
@@ -69,5 +74,23 @@ export function usePagedCollection(fetchPage, { enabled = true } = {}) {
const setItems = useCallback(update => commit({ ...state.current,
items: typeof update === 'function' ? update(state.current.items) : update }), [commit]);
- return { ...page, setItems, hasMore: !page.loaded || page.nextCursor != null, loadMore, reload, refreshFirst };
+ // Apply a confirmed deletion without resetting already loaded pages. A read
+ // started before the mutation may still contain the removed row: invalidate
+ // it and replay the same cursor/refresh so concurrent arrivals are not lost.
+ const removeItem = useCallback(id => {
+ const interrupted = pending.current;
+ const restart = restartPending.current;
+ generation.current += 1;
+ interrupted?.abort();
+ pending.current = null;
+ const previous = state.current;
+ const items = previous.items.filter(item => item.id !== id);
+ // A concurrent response may already include the deletion in its total,
+ // even while the additive history merge retained the row. Never subtract
+ // twice: reconcile the count from a read started after confirmation.
+ commit({ ...previous, items, loading: false });
+ return interrupted ? restart() : currentRead.current(true);
+ }, [commit]);
+
+ return { ...page, setItems, removeItem, hasMore: !page.loaded || page.nextCursor != null, loadMore, reload, refreshFirst };
}
diff --git a/client/src/hooks/usePagedCollection.test.jsx b/client/src/hooks/usePagedCollection.test.jsx
new file mode 100644
index 0000000000..e5878ba475
--- /dev/null
+++ b/client/src/hooks/usePagedCollection.test.jsx
@@ -0,0 +1,103 @@
+import { describe, expect, it, vi } from 'vitest';
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { usePagedCollection } from './usePagedCollection';
+
+const deferred = () => {
+ let resolve;
+ let reject;
+ const promise = new Promise((res, rej) => { resolve = res; reject = rej; });
+ return { promise, resolve, reject };
+};
+const row = id => ({ id });
+
+describe('usePagedCollection confirmed removal', () => {
+ it('retains keyset pagination and reconciles the count without double subtraction', async () => {
+ const survivor = row('survivor');
+ const fetchPage = vi.fn().mockResolvedValueOnce({ items: [row('cursor-row'), survivor], total: 3, nextCursor: 'cursor-row' })
+ .mockResolvedValueOnce({ items: [survivor], total: 2, nextCursor: 'survivor' })
+ .mockResolvedValueOnce({ items: [survivor], total: 2, nextCursor: 'survivor' })
+ .mockResolvedValueOnce({ items: [row('older')], total: 2, nextCursor: null });
+ const { result } = renderHook(() => usePagedCollection(fetchPage));
+ await waitFor(() => expect(result.current.loaded).toBe(true));
+ await act(async () => result.current.removeItem('cursor-row'));
+ await act(async () => result.current.removeItem('cursor-row'));
+ expect(result.current.items).toEqual([survivor]);
+ expect(result.current.items[0]).toBe(survivor);
+ expect(result.current.total).toBe(2);
+ expect(result.current.nextCursor).toBe('cursor-row');
+ expect(result.current.loading).toBe(false);
+ expect(fetchPage).toHaveBeenCalledTimes(3);
+ await act(async () => result.current.loadMore());
+ expect(fetchPage).toHaveBeenLastCalledWith(expect.objectContaining({ cursor: 'cursor-row' }));
+ expect(result.current.items.map(item => item.id)).toEqual(['survivor', 'older']);
+ expect(result.current.hasMore).toBe(false);
+ });
+
+ it('rejects pre-delete refreshes and preserves queued socket arrivals and older pages', async () => {
+ const stale = deferred();
+ const fresh = deferred();
+ const last = deferred();
+ const fetchPage = vi.fn()
+ .mockResolvedValueOnce({ items: [row('removed'), row('survivor'), row('older')], total: 4, nextCursor: 'older' })
+ .mockReturnValueOnce(stale.promise).mockReturnValueOnce(fresh.promise).mockReturnValueOnce(last.promise);
+ const { result } = renderHook(() => usePagedCollection(fetchPage));
+ await waitFor(() => expect(result.current.loaded).toBe(true));
+ act(() => { void result.current.refreshFirst(); });
+ const staleSignal = fetchPage.mock.calls[1][0].signal;
+ act(() => { void result.current.refreshFirst(); }); // a completion arrives during the read
+ act(() => { void result.current.removeItem('removed'); });
+ expect(staleSignal.aborted).toBe(true);
+ expect(result.current.items.map(item => item.id)).toEqual(['survivor', 'older']);
+ expect(result.current.total).toBe(4);
+ await act(async () => fresh.resolve({ items: [row('new'), row('survivor')], total: 4, nextCursor: 'survivor' }));
+ expect(fetchPage).toHaveBeenCalledTimes(4); // queued completion is still serviced
+ await act(async () => stale.resolve({ items: [row('removed')], total: 99, nextCursor: null }));
+ expect(result.current.items.map(item => item.id)).toEqual(['new', 'survivor', 'older']);
+ expect(result.current.total).toBe(4);
+ await act(async () => last.resolve({ items: [row('newest'), row('new'), row('survivor')], total: 5, nextCursor: 'survivor' }));
+ expect(result.current.items.map(item => item.id)).toEqual(['newest', 'new', 'survivor', 'older']);
+ expect(result.current.nextCursor).toBe('older');
+ expect(result.current.loading).toBe(false);
+ expect(result.current.error).toBeNull();
+ });
+
+ it('replays an interrupted next page at its cursor and keeps retry state usable on failure', async () => {
+ const stale = deferred();
+ const replacement = deferred();
+ const fetchPage = vi.fn()
+ .mockResolvedValueOnce({ items: [row('removed'), row('survivor')], total: 3, nextCursor: 'boundary' })
+ .mockReturnValueOnce(stale.promise).mockReturnValueOnce(replacement.promise)
+ .mockResolvedValueOnce({ items: [row('older')], total: 2, nextCursor: null });
+ const { result } = renderHook(() => usePagedCollection(fetchPage));
+ await waitFor(() => expect(result.current.loaded).toBe(true));
+ act(() => { void result.current.loadMore(); });
+ act(() => { void result.current.removeItem('removed'); });
+ expect(fetchPage.mock.calls.slice(1).map(([request]) => request.cursor)).toEqual(['boundary', 'boundary']);
+ await act(async () => replacement.reject(new Error('Page unavailable')));
+ await act(async () => stale.resolve({ items: [row('removed')], total: 3, nextCursor: null }));
+ expect(result.current.items.map(item => item.id)).toEqual(['survivor']);
+ expect(result.current.loading).toBe(false);
+ expect(result.current.error.message).toBe('Page unavailable');
+ await act(async () => result.current.loadMore());
+ expect(fetchPage).toHaveBeenLastCalledWith(expect.objectContaining({ cursor: 'boundary' }));
+ expect(result.current.items.map(item => item.id)).toEqual(['survivor', 'older']);
+ expect(result.current.error).toBeNull();
+ expect(result.current.loading).toBe(false);
+ });
+});
+
+
+it('reconciles a delayed mutation against the current filter even with no pending read', async () => {
+ const firstQuery = vi.fn().mockResolvedValue({ items: [row('removed')], total: 1, nextCursor: null });
+ const secondQuery = vi.fn().mockResolvedValue({ items: [row('kept')], total: 1, nextCursor: null });
+ const { result, rerender } = renderHook(({ query }) => usePagedCollection(query), { initialProps: { query: firstQuery } });
+ await waitFor(() => expect(result.current.loaded).toBe(true));
+ const finishOldDelete = result.current.removeItem;
+ rerender({ query: secondQuery });
+ await waitFor(() => expect(result.current.items.map(item => item.id)).toEqual(['kept']));
+ await act(async () => finishOldDelete('removed'));
+ expect(firstQuery).toHaveBeenCalledTimes(1);
+ expect(secondQuery).toHaveBeenCalledTimes(2);
+ expect(result.current.items.map(item => item.id)).toEqual(['kept']);
+ expect(result.current.total).toBe(1);
+});