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
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
import { beforeEach, describe, expect, it, vi } from 'vitest';
import { act, render, screen, waitFor } from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import { MemoryRouter } from 'react-router';
import { __resetToolUseModelIdsCache } from '../../../hooks/useToolUseModelIds.js';
const toast = vi.hoisted(() => ({ success: vi.fn(), error: vi.fn() }));
const api = vi.hoisted(() => ({
getCodeReviewDefaults: vi.fn(),
getCosSchedule: vi.fn(),
triggerCosOnDemandTask: vi.fn(),
updateCosTaskInterval: vi.fn(),
getLocalLlmStatus: vi.fn().mockResolvedValue(null),
getProviders: vi.fn().mockResolvedValue({ providers: [] }),
}));
const socket = vi.hoisted(() => ({ on: vi.fn(), off: vi.fn(), emit: vi.fn() }));
vi.mock('../../../services/socket', () => ({ default: socket }));
const apiLocalLlm = vi.hoisted(() => ({ getToolUseModels: vi.fn() }));
vi.mock('../../../services/apiLocalLlm', () => apiLocalLlm);
vi.mock('../../ui/Toast', () => ({ default: toast }));
vi.mock('../../../services/api', () => api);
const { default: ScheduleTab, mergeUpdatedTaskInterval } = await import('./ScheduleTab');
beforeEach(() => {
__resetToolUseModelIdsCache();
apiLocalLlm.getToolUseModels.mockResolvedValue({ models: [] });
});
describe('mergeUpdatedTaskInterval', () => {
it('applies the persisted interval while retaining derived schedule status', () => {
const schedule = {
lastUpdated: 'earlier',
tasks: {
'plan-feature': {
dataInputs: ['project-goals'],
enabledAppCount: 2,
status: { shouldRun: false },
},
},
};
expect(mergeUpdatedTaskInterval(schedule, 'plan-feature', {
dataInputs: ['project-goals', 'open-issues'],
})).toEqual({
...schedule,
tasks: {
'plan-feature': {
dataInputs: ['project-goals', 'open-issues'],
enabledAppCount: 2,
status: { shouldRun: false },
},
},
});
expect(schedule.tasks['plan-feature'].dataInputs).toEqual(['project-goals']);
});
it('replaces stale derived status when a mutation returns its post-write status', () => {
const status = {
shouldRun: false,
reason: 'cron-cooldown',
cronExpression: '0 3 * * 0,1,3,4,5,6',
nextRunAt: '2026-09-23T10:00:00.000Z',
};
const schedule = {
tasks: {
'do-release': {
type: 'cron',
cronExpression: '0 3 * * 0-6',
status: { shouldRun: false, nextRunAt: '2026-09-22T10:00:00.000Z' },
},
},
};
expect(mergeUpdatedTaskInterval(schedule, 'do-release', {
type: 'cron',
cronExpression: status.cronExpression,
}, status).tasks['do-release'].status).toEqual(status);
});
});
describe('ScheduleTab on-demand feedback', () => {
it('retains the last schedule on a failed refresh, shows the failure, and recovers', async () => {
const user = userEvent.setup();
api.getCodeReviewDefaults.mockResolvedValue({});
const schedule = { tasks: { review: { type: 'on-demand', enabled: true, displayName: 'Example Review' } } };
api.getCosSchedule
.mockResolvedValueOnce(schedule)
.mockRejectedValueOnce(new Error('app cadence unavailable'))
.mockResolvedValueOnce({ ...schedule, tasks: { review: { ...schedule.tasks.review, displayName: 'Recovered Review' } } });
render(<MemoryRouter><ScheduleTab apps={[]} providers={[]} /></MemoryRouter>);
expect(await screen.findByText('Example Review')).toBeVisible();
await user.click(screen.getByRole('button', { name: 'Refresh' }));
expect(await screen.findByRole('alert')).toHaveTextContent('Schedule unavailable — showing the last loaded schedule');
expect(screen.getByRole('alert')).toHaveTextContent('app cadence unavailable');
expect(screen.getByText('Example Review')).toBeVisible();
await user.click(screen.getByRole('button', { name: 'Refresh' }));
expect(await screen.findByText('Recovered Review')).toBeVisible();
expect(screen.queryByRole('alert')).not.toBeInTheDocument();
expect(api.getCosSchedule).toHaveBeenLastCalledWith({ silent: true });
});
it('allows an initial unavailable schedule to be retried successfully with an empty schedule', async () => {
const user = userEvent.setup();
api.getCodeReviewDefaults.mockResolvedValue({});
api.getCosSchedule.mockRejectedValueOnce(new Error('app registry unavailable')).mockResolvedValueOnce({ tasks: {} });
render(<MemoryRouter><ScheduleTab apps={[]} providers={[]} /></MemoryRouter>);
expect(await screen.findByText('Failed to load task schedule')).toBeVisible();
await user.click(screen.getByRole('button', { name: 'Retry' }));
expect(await screen.findByText('Task Schedule')).toBeVisible();
expect(screen.queryByText('Failed to load task schedule')).not.toBeInTheDocument();
});
it('names the selected app and paints the returned request before the refresh settles', async () => {
const user = userEvent.setup();
const request = {
id: 'request-1',
taskType: 'review',
appId: 'app-1',
requestedAt: '2026-09-01T12:00:00.000Z',
};
api.getCodeReviewDefaults.mockResolvedValue({});
api.getCosSchedule
.mockResolvedValueOnce({
improvementEnabled: true,
tasks: {
review: {
type: 'on-demand',
enabled: true,
enabledAppCount: 1,
totalAppCount: 1,
invocation: { userInvokable: true },
},
},
onDemandRequests: [],
})
// Hold the background refresh so this assertion uniquely proves the
// mutation response updates the visible schedule immediately.
.mockReturnValueOnce(new Promise(() => {}));
api.triggerCosOnDemandTask.mockResolvedValue({ success: true, request });
render(
<MemoryRouter>
<ScheduleTab
apps={[{ id: 'app-1', name: 'Example App' }]}
providers={[]}
activeProviderId={null}
/>
</MemoryRouter>,
);
await user.click(await screen.findByRole('button', { name: /Run on App/i }));
await user.click(screen.getByRole('button', { name: 'Example App' }));
await waitFor(() => expect(api.triggerCosOnDemandTask).toHaveBeenCalledWith(
'review',
'app-1',
{ silent: true },
));
expect(toast.success).toHaveBeenCalledWith(
'Queued review request for Example App — it will appear in Tasks when evaluation begins',
);
expect(await screen.findByText('Request queued for Example App')).toBeVisible();
expect(screen.getByText('Pending On-Demand Tasks')).toBeVisible();
expect(screen.getByText(/review \(Example App\) - requested/)).toBeVisible();
});
it('warns instead of celebrating a queued request when the CoS daemon is stopped', async () => {
const user = userEvent.setup();
const request = {
id: 'request-2',
taskType: 'review',
appId: 'app-1',
requestedAt: '2026-09-01T12:00:00.000Z',
};
api.getCodeReviewDefaults.mockResolvedValue({});
api.getCosSchedule
.mockResolvedValueOnce({
improvementEnabled: true,
tasks: {
review: {
type: 'on-demand',
enabled: true,
enabledAppCount: 1,
totalAppCount: 1,
invocation: { userInvokable: true },
},
},
onDemandRequests: [],
})
// Hold the background refresh so this assertion proves the
// optimistically-painted request (and its daemon-stopped warning)
// stays visible without waiting on a second round trip.
.mockReturnValueOnce(new Promise(() => {}));
api.triggerCosOnDemandTask.mockResolvedValue({ success: true, request });
render(
<MemoryRouter>
<ScheduleTab
apps={[{ id: 'app-1', name: 'Example App' }]}
providers={[]}
activeProviderId={null}
daemonRunning={false}
/>
</MemoryRouter>,
);
await user.click(await screen.findByRole('button', { name: /Run on App/i }));
await user.click(screen.getByRole('button', { name: 'Example App' }));
await waitFor(() => expect(api.triggerCosOnDemandTask).toHaveBeenCalledWith(
'review',
'app-1',
{ silent: true },
));
expect(toast.error).toHaveBeenCalledWith(
'Queued review request for Example App — but the CoS daemon is stopped, so it will not run until you start it',
);
expect(await screen.findByText(/CoS daemon is stopped/)).toBeVisible();
});
});
describe('Schedule labels', () => {
it('filters by a linked label, searches legacy names, and saves custom labels through the drawer', async () => {
const user = userEvent.setup();
api.getCodeReviewDefaults.mockResolvedValue({});
api.getCosSchedule.mockResolvedValue({ tasks: {
security: { type: 'on-demand', enabled: false, displayName: 'better-security', defaultLabels: ['slashdo'], labels: [], description: 'Security audit' },
'claim-issue': { type: 'on-demand', enabled: false, description: 'Claim work' },
} });
api.updateCosTaskInterval.mockResolvedValue({ success: true, interval: { labels: ['backend'] } });
render(<MemoryRouter initialEntries={['/cos/schedule?label=slashdo']}><ScheduleTab apps={[]} providers={[]} providersLoaded /></MemoryRouter>);
expect(await screen.findByText('better-security')).toBeTruthy();
expect(screen.queryByText('claim-issue')).toBeNull();
await user.click(screen.getByRole('button', { name: 'Clear label' }));
expect(screen.getByText('claim-issue')).toBeTruthy();
await user.type(screen.getByRole('textbox', { name: 'Filter tasks by name' }), 'security');
expect(screen.queryByText('claim-issue')).toBeNull();
await user.click(screen.getByText('better-security'));
const labels = await screen.findByRole('textbox', { name: 'Custom labels' });
await user.type(labels, 'backend');
await user.tab();
await waitFor(() => expect(api.updateCosTaskInterval).toHaveBeenCalledWith('security', { labels: ['backend'] }, { silent: true }));
expect(await screen.findByRole('option', { name: 'backend (1)' })).toBeTruthy();
});
});
it('keeps the last saved schedule after a refresh failure', async () => {
const user = userEvent.setup();
api.getCodeReviewDefaults.mockResolvedValue({});
api.getCosSchedule.mockReset().mockResolvedValueOnce({
tasks: {
security: { type: 'on-demand', enabled: true, displayName: 'Security' },
},
}).mockRejectedValueOnce(new Error('offline'));
render(<MemoryRouter><ScheduleTab apps={[{ id: 'example', name: 'Example App' }]} providers={[]} providersLoaded /></MemoryRouter>);
expect(await screen.findByText('Security')).toBeVisible();
await user.click(screen.getByRole('button', { name: 'Refresh' }));
await waitFor(() => expect(api.getCosSchedule).toHaveBeenCalledTimes(2));
expect(screen.getByText('Security')).toBeVisible();
expect(screen.queryByText('Failed to load task schedule')).not.toBeInTheDocument();
});
it('refreshes the reconciliation inventory on a schedule event without polling', async () => {
const config = { type: 'on-demand', enabled: true, displayName: 'Branch Reconciler' };
api.getCodeReviewDefaults.mockResolvedValue({});
api.getCosSchedule.mockReset().mockResolvedValueOnce({ tasks: { 'branch-reconcile': config } })
.mockResolvedValueOnce({ tasks: { 'branch-reconcile': { ...config, reconcileOutcomes: {
example: { status: 'incomplete', reason: 'worktree-locked', observedAt: '2026-10-01T00:00:00Z', remaining: [
{ path: '/example/held', reason: 'worktree-locked', locked: true, lockReason: 'owner handoff' },
] },
} } } });
render(<MemoryRouter><ScheduleTab apps={[{ id: 'example', name: 'Example App' }]} providers={[]} providersLoaded /></MemoryRouter>);
await screen.findByText('Branch Reconciler');
const handler = socket.on.mock.calls.findLast(([event]) => event === 'cos:schedule:changed')[1];
await act(async () => handler());
expect(await screen.findByText(/Example App · Incomplete/)).toBeTruthy();
expect(screen.getByText('Lock: owner handoff')).toBeTruthy();
expect(api.getCosSchedule).toHaveBeenCalledTimes(2);
});