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 { useState } from 'react';
import { describe, it, expect, vi } from 'vitest';
import { render, screen, fireEvent } from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import ReviewerPicker from './ReviewerPicker';
import { typeSettled } from '../../test/settledInput';
describe('ReviewerPicker', () => {
it('clears an incompatible provider effort when its model changes and announces why', () => {
const provider = { id: 'example-codex', name: 'Example Codex', command: 'codex', enabled: true,
defaultModel: 'gpt-5.6-sol', models: ['gpt-5.6-sol', 'gpt-6-astra'] };
const token = 'provider:example-codex';
const onChange = vi.fn();
function Form() {
const [config, setConfig] = useState({
reviewers: [token], reviewerModels: { [token]: 'gpt-5.6-sol' },
reviewerEfforts: { [token]: 'minimal', claude: 'high' },
});
return <ReviewerPicker {...config} modelOptions={{ providers: [provider], optionsByReviewer: { [token]: provider.models } }}
onChange={value => { onChange(value); setConfig(value); }} />;
}
render(<Form />);
fireEvent.change(screen.getByLabelText('Model for Example Codex'), { target: { value: 'gpt-6-astra' } });
expect(screen.getByLabelText('Reasoning effort for Example Codex')).toHaveValue('');
expect(onChange.mock.lastCall[0].reviewerEfforts).toEqual({ claude: 'high' });
expect(screen.getByRole('status')).toHaveTextContent('new model does not support minimal');
fireEvent.change(screen.getByLabelText('Reasoning effort for Example Codex'), { target: { value: 'high' } });
fireEvent.change(screen.getByLabelText('Model for Example Codex'), { target: { value: 'gpt-5.6-sol' } });
expect(onChange.mock.lastCall[0].reviewerEfforts).toEqual({ [token]: 'high', claude: 'high' });
});
it('keeps an incompatible saved provider effort visible and clearable without mutating on mount', () => {
const onChange = vi.fn();
const token = 'provider:example-codex';
render(<ReviewerPicker reviewers={[token]} reviewerModels={{ [token]: 'gpt-6-astra' }}
reviewerEfforts={{ [token]: 'minimal' }} onChange={onChange}
modelOptions={{ providers: [{ id: 'example-codex', name: 'Example Codex', command: 'codex' }] }} />);
const effort = screen.getByLabelText('Reasoning effort for Example Codex');
expect(effort).toHaveValue('minimal');
expect(screen.getByRole('option', { name: 'minimal (unsupported)' })).toBeInTheDocument();
expect(effort).toHaveAttribute('title', expect.stringContaining('does not support minimal'));
expect(onChange).not.toHaveBeenCalled();
fireEvent.change(effort, { target: { value: '' } });
expect(onChange.mock.lastCall[0].reviewerEfforts).toEqual({});
});
it('adds, edits, and clears effort for a configured provider reviewer', () => {
const onChange = vi.fn();
const providers = [{ id: 'codex-tui', name: 'Codex TUI', command: 'codex', enabled: true, defaultModel: 'gpt-6-astra', models: ['gpt-6-astra'] }];
function Form() {
const [config, setConfig] = useState({ reviewers: [] });
return <ReviewerPicker {...config} modelOptions={{ providers }} onChange={value => { onChange(value); setConfig(value); }} />;
}
render(<Form />);
fireEvent.change(screen.getByLabelText('Add AI provider'), { target: { value: 'codex-tui' } });
fireEvent.change(screen.getByLabelText('Reasoning effort for Codex TUI'), { target: { value: 'ultra' } });
const effort = screen.getByLabelText('Reasoning effort for Codex TUI');
expect(effort).toHaveValue('ultra');
expect([...effort.options].map(option => option.value)).not.toContain('minimal');
fireEvent.change(effort, { target: { value: 'high' } });
expect(onChange.mock.lastCall[0].reviewerEfforts).toEqual({ 'provider:codex-tui': 'high' });
fireEvent.change(effort, { target: { value: '' } });
expect(onChange.mock.lastCall[0].reviewerEfforts).toEqual({});
});
it('renders the selected reviewers in order with numbered badges', () => {
render(<ReviewerPicker reviewers={['codex', 'antigravity', 'copilot']} onChange={() => {}} />);
expect(screen.getByText('1.')).toBeInTheDocument();
expect(screen.getByText('2.')).toBeInTheDocument();
expect(screen.getByText('3.')).toBeInTheDocument();
// The not-yet-selected reviewer (claude) shows in the Add row.
expect(screen.getByRole('option', { name: 'Claude' })).toBeInTheDocument();
});
describe('installed badge (#3606)', () => {
it('flags a selected reviewer whose CLI probe came back false', () => {
render(<ReviewerPicker reviewers={['antigravity']} installed={{ antigravity: false }} onChange={() => {}} />);
expect(screen.getByText('not installed')).toBeInTheDocument();
});
it('does not flag a selected reviewer with no probe entry (not a CLI reviewer, or not fetched)', () => {
render(<ReviewerPicker reviewers={['copilot']} installed={{ antigravity: false }} onChange={() => {}} />);
// copilot has no `installed` entry (it's not a CLI reviewer) — its row
// stays unbadged even though the map has an entry for a different reviewer.
expect(screen.getByText('Copilot').closest('div')).not.toHaveTextContent('not installed');
});
it('does not flag anything when installed is absent', () => {
render(<ReviewerPicker reviewers={['codex', 'antigravity']} onChange={() => {}} />);
expect(screen.queryByText('not installed')).not.toBeInTheDocument();
});
it('flags an unselected reviewer in the Add menu', () => {
render(<ReviewerPicker reviewers={['copilot']} installed={{ antigravity: false }} onChange={() => {}} />);
expect(screen.getByRole('option', { name: /Antigravity/ })).toHaveTextContent('not installed');
});
});
// A local backend answers from its own daemon, so the live probe is the only
// thing that can say whether it will review — a same-named AI-provider record
// being switched off says nothing about it (see the hook's exemption).
describe('local-backend reachability badge', () => {
it('flags a local backend whose probe reports it down', () => {
render(<ReviewerPicker reviewers={['lmstudio']} modelOptions={{ loaded: true, unavailable: { lmstudio: true } }} onChange={() => {}} />);
expect(screen.getByText('not running')).toBeInTheDocument();
});
it('leaves a reachable local backend unbadged', () => {
render(<ReviewerPicker reviewers={['lmstudio']} modelOptions={{ loaded: true, unavailable: { lmstudio: false } }} onChange={() => {}} />);
expect(screen.queryByText('not running')).not.toBeInTheDocument();
expect(screen.queryByText('disabled')).not.toBeInTheDocument();
});
it('says nothing before the probe has landed', () => {
render(<ReviewerPicker reviewers={['lmstudio']} modelOptions={{ loaded: false }} onChange={() => {}} />);
expect(screen.queryByText('not running')).not.toBeInTheDocument();
});
});
// #7660: an enabled, present provider that still has no enforceable tool-free
// review transport is the one case nothing used to say out loud — the user
// found out only when every PR it gated sat unmergeable forever.
describe("provider reviewer that can't review (#7660)", () => {
const providers = [{ id: 'hosted-harness', name: 'Hosted Harness', command: 'opencode', enabled: true, models: [] }];
it('flags an enabled provider reported as unable to run any review', () => {
render(
<ReviewerPicker
reviewers={['provider:hosted-harness']}
modelOptions={{ loaded: true, providers }}
providerReviewUnsupported={{ 'provider:hosted-harness': 'REVIEWER_UNSUPPORTED' }}
onChange={() => {}}
/>
);
expect(screen.getByText("can't review")).toHaveAttribute('title', expect.stringContaining('Set its command or switch it to API mode'));
});
it('says nothing about a provider absent from the map, or when it was never fetched', () => {
const { rerender } = render(
<ReviewerPicker
reviewers={['provider:hosted-harness']}
modelOptions={{ loaded: true, providers }}
providerReviewUnsupported={{ 'provider:other': 'REVIEWER_UNSUPPORTED' }}
onChange={() => {}}
/>
);
expect(screen.queryByText("can't review")).not.toBeInTheDocument();
rerender(
<ReviewerPicker
reviewers={['provider:hosted-harness']}
modelOptions={{ loaded: true, providers }}
onChange={() => {}}
/>
);
expect(screen.queryByText("can't review")).not.toBeInTheDocument();
});
it('keeps the more specific word for a switched-off provider rather than badging it twice', () => {
render(
<ReviewerPicker
reviewers={['provider:hosted-harness']}
modelOptions={{ loaded: true, providers: [{ ...providers[0], enabled: false }] }}
providerReviewUnsupported={{ 'provider:hosted-harness': 'REVIEWER_UNSUPPORTED' }}
onChange={() => {}}
/>
);
expect(screen.getByText('disabled')).toBeInTheDocument();
expect(screen.queryByText("can't review")).not.toBeInTheDocument();
});
});
it('offers CLI and API providers as new reviewers, but not TUI records', () => {
render(
<ReviewerPicker
reviewers={[]}
modelOptions={{ loaded: true, providers: [
{ id: 'example-cli', name: 'Example CLI', type: 'cli', command: 'agy', enabled: true, models: [] },
{ id: 'example-api', name: 'Example API', type: 'api', enabled: true, models: [] },
{ id: 'example-tui', name: 'Example TUI', type: 'tui', command: 'agy', enabled: true, models: [] },
] }}
onChange={() => {}}
/>
);
expect(screen.getByRole('option', { name: /Example CLI/ })).toBeInTheDocument();
expect(screen.getByRole('option', { name: /Example API/ })).toBeInTheDocument();
expect(screen.queryByRole('option', { name: /Example TUI/ })).not.toBeInTheDocument();
});
// The Add row lists what this machine can actually run. Hidden, not dropped:
// both signals are local-machine-only and the reviewer list is
// federation-wide config, so a peer's reviewer stays configurable from here.
describe('unavailable reviewers in the Add row', () => {
const modelOptions = { providerDisabled: { kimi: true, cursor: true } };
it('labels missing and disabled backends in the legacy selector', () => {
render(
<ReviewerPicker
reviewers={['copilot']}
installed={{ antigravity: false }}
modelOptions={modelOptions}
onChange={() => {}}
/>
);
expect(screen.getByRole('option', { name: /Antigravity/ })).toHaveTextContent('not installed');
expect(screen.getByRole('option', { name: /Kimi/ })).toHaveTextContent('disabled');
expect(screen.getByRole('option', { name: /Codex/ })).toHaveTextContent('Codex');
});
it('reveals them, badged with which signal fired, and adds them normally', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(
<ReviewerPicker
reviewers={['copilot']}
installed={{ antigravity: false }}
modelOptions={modelOptions}
onChange={onChange}
/>
);
expect(screen.getByRole('option', { name: /Kimi/ })).toHaveTextContent('disabled');
expect(screen.getByRole('option', { name: /Antigravity/ })).toHaveTextContent('not installed');
await user.selectOptions(screen.getByLabelText('Add local / CLI'), 'kimi');
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ reviewers: ['copilot', 'kimi'] }));
});
it('keeps an already-selected unavailable reviewer visible, badged', () => {
render(
<ReviewerPicker reviewers={['kimi']} modelOptions={modelOptions} onChange={() => {}} />
);
expect(screen.getByText('Kimi').parentElement).toHaveTextContent('disabled');
});
it('offers the whole roster when neither signal was fetched', () => {
render(<ReviewerPicker reviewers={['copilot']} onChange={() => {}} />);
expect(screen.queryByRole('option', { name: /unavailable/ })).not.toBeInTheDocument();
expect(screen.getByRole('option', { name: /Kimi/ })).toBeInTheDocument();
});
});
it('shows the empty-state hint when no reviewers are selected', () => {
render(<ReviewerPicker reviewers={[]} onChange={() => {}} />);
expect(screen.getByText('None')).toBeInTheDocument();
});
it('de-dupes a malformed list with duplicates (order-preserving)', () => {
render(<ReviewerPicker reviewers={['codex', 'codex', 'antigravity']} onChange={() => {}} />);
// Two distinct pills (badges 1 and 2), not three.
expect(screen.getByText('1.')).toBeInTheDocument();
expect(screen.getByText('2.')).toBeInTheDocument();
expect(screen.queryByText('3.')).not.toBeInTheDocument();
});
it('emits an empty list when the last reviewer is removed (server resolves to copilot)', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(<ReviewerPicker reviewers={['copilot']} onChange={onChange} />);
await user.click(screen.getByLabelText('Remove Copilot'));
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ reviewers: [] }));
});
it('appends a reviewer in click order on add', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(<ReviewerPicker reviewers={['copilot']} onChange={onChange} />);
await user.selectOptions(screen.getByLabelText('Add local / CLI'), 'codex');
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ reviewers: ['copilot', 'codex'] }));
});
it('reorders with the up arrow', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(<ReviewerPicker reviewers={['codex', 'antigravity', 'copilot']} onChange={onChange} />);
await user.click(screen.getByLabelText('Move Antigravity earlier'));
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ reviewers: ['antigravity', 'codex', 'copilot'] }));
});
it('removes a reviewer', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(<ReviewerPicker reviewers={['codex', 'copilot']} onChange={onChange} />);
await user.click(screen.getByLabelText('Remove Codex'));
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ reviewers: ['copilot'] }));
});
it('shows the stop-mode select only for 2+ reviewers', () => {
const { rerender } = render(<ReviewerPicker reviewers={['codex']} onChange={() => {}} />);
expect(screen.queryByText('Stop mode:')).not.toBeInTheDocument();
rerender(<ReviewerPicker reviewers={['codex', 'antigravity']} onChange={() => {}} />);
expect(screen.getByText('Stop mode:')).toBeInTheDocument();
});
it('normalizes legacy Gemini reviewer values to Antigravity', () => {
render(<ReviewerPicker reviewers={['gemini']} onChange={() => {}} />);
expect(screen.getByText('Antigravity')).toBeInTheDocument();
});
// slashdo's loop grants the editing pass to codex alone and forces every other
// local reviewer back to review-only, reverting whatever it wrote. Offering the
// toggle for agy asked the user to grant write access that buys them nothing.
it('shows the reviewer-applies toggle only when codex is selected', () => {
const { rerender } = render(<ReviewerPicker reviewers={['copilot']} onChange={() => {}} />);
expect(screen.queryByText(/Reviewer applies fixes/)).not.toBeInTheDocument();
rerender(<ReviewerPicker reviewers={['antigravity', 'grok']} onChange={() => {}} />);
expect(screen.queryByText(/Reviewer applies fixes/)).not.toBeInTheDocument();
rerender(<ReviewerPicker reviewers={['codex']} onChange={() => {}} />);
expect(screen.getByText(/Reviewer applies fixes/)).toBeInTheDocument();
});
it('adds a GitHub/GitLab reviewer username (strips @) via the Add button', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(<ReviewerPicker reviewers={['copilot']} onChange={onChange} />);
await typeSettled(user, screen.getByLabelText('Add a GitHub/GitLab reviewer username'), '@CodeReviewbot');
await user.click(screen.getByRole('button', { name: 'Add reviewer username' }));
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ usernames: ['CodeReviewbot'] }));
});
it('adds a username on Enter', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(<ReviewerPicker reviewers={['copilot']} onChange={onChange} />);
// Enter is pressed separately so the draft can be pinned first: the keydown
// handler adds whatever `usernameInput` state holds at that moment.
await typeSettled(user, screen.getByLabelText('Add a GitHub/GitLab reviewer username'), 'reviewer-bot');
await user.keyboard('{Enter}');
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ usernames: ['reviewer-bot'] }));
});
it('rejects an invalid username and surfaces an error without emitting', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(<ReviewerPicker reviewers={['copilot']} onChange={onChange} />);
// Same pin: a partially-typed `bad` is a *valid* username, so an Enter that
// beat the last keystrokes would emit and make this assertion lie.
await typeSettled(user, screen.getByLabelText('Add a GitHub/GitLab reviewer username'), 'bad-token!');
await user.keyboard('{Enter}');
expect(onChange).not.toHaveBeenCalled();
expect(screen.getByRole('alert')).toHaveTextContent('Invalid reviewer names: bad-token!');
});
it('renders existing username pills and removes one', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(<ReviewerPicker reviewers={['copilot']} usernames={['CodeReviewbot', 'other-bot']} onChange={onChange} />);
expect(screen.getByText('CodeReviewbot')).toBeInTheDocument();
await user.click(screen.getByLabelText('Remove @CodeReviewbot'));
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ usernames: ['other-bot'] }));
});
it('adds comma/space separated forge usernames as one validated, deduplicated batch', () => {
const onChange = vi.fn();
render(<ReviewerPicker usernames={['Alice']} onChange={onChange} />);
const input = screen.getByLabelText('Add a GitHub/GitLab reviewer username');
fireEvent.change(input, { target: { value: '@alice, bob.team carol_dev' } });
fireEvent.click(screen.getByLabelText('Add reviewer username'));
expect(onChange.mock.lastCall[0].usernames).toEqual(['Alice', 'bob.team', 'carol_dev']);
onChange.mockClear();
fireEvent.change(input, { target: { value: 'valid-user, not-valid!' } });
fireEvent.click(screen.getByLabelText('Add reviewer username'));
expect(screen.getByRole('alert')).toHaveTextContent('Invalid reviewer names: not-valid!');
expect(input).toHaveValue('valid-user, not-valid!');
expect(onChange).not.toHaveBeenCalled();
fireEvent.change(input, { target: { value: Array.from({ length: 20 }, (_, index) => `reviewer-${index}`).join(',') } });
fireEvent.click(screen.getByLabelText('Add reviewer username'));
expect(screen.getByRole('alert')).toHaveTextContent('At most 20 reviewer usernames');
expect(onChange).not.toHaveBeenCalled();
});
it('toggles a keyed reviewer non-blocking (adds its slug to optionalReviewers)', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(<ReviewerPicker reviewers={['codex', 'ollama']} onChange={onChange} />);
await user.click(screen.getByLabelText('Make Ollama non-blocking'));
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ optionalReviewers: ['ollama'] }));
});
it('toggles a non-blocking reviewer back to blocking (removes it)', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(<ReviewerPicker reviewers={['codex', 'ollama']} optionalReviewers={['ollama']} onChange={onChange} />);
await user.click(screen.getByLabelText('Make Ollama blocking'));
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ optionalReviewers: [] }));
});
it('marks a GitHub/GitLab reviewer username non-blocking with the @-form token', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(<ReviewerPicker reviewers={['copilot']} usernames={['flaky-bot']} onChange={onChange} />);
await user.click(screen.getByLabelText('Make @flaky-bot non-blocking'));
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ optionalReviewers: ['@flaky-bot'] }));
});
it('prunes the optional token when its reviewer is removed', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(<ReviewerPicker reviewers={['codex', 'ollama']} optionalReviewers={['ollama']} onChange={onChange} />);
await user.click(screen.getByLabelText('Remove Ollama'));
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ reviewers: ['codex'], optionalReviewers: [] }));
});
describe('~max round caps', () => {
it('renders a blank cap input per reviewer/username chip when no cap is set', () => {
render(<ReviewerPicker reviewers={['codex', 'ollama']} usernames={['flaky-bot']} onChange={() => {}} />);
expect(screen.getByLabelText('Max review rounds for Codex')).toHaveValue(null);
expect(screen.getByLabelText('Max review rounds for Ollama')).toHaveValue(null);
expect(screen.getByLabelText('Max review rounds for @flaky-bot')).toHaveValue(null);
});
it('shows an existing cap, including an explicit 0', () => {
render(<ReviewerPicker reviewers={['codex', 'ollama']} reviewerMaxRounds={{ ollama: 0, codex: 2 }} onChange={() => {}} />);
// 0 is a real value (loop until clean) and must render as 0, not blank.
expect(screen.getByLabelText('Max review rounds for Ollama')).toHaveValue(0);
expect(screen.getByLabelText('Max review rounds for Codex')).toHaveValue(2);
});
it('sets a cap for a keyed reviewer', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(<ReviewerPicker reviewers={['codex', 'ollama']} onChange={onChange} />);
await user.type(screen.getByLabelText('Max review rounds for Ollama'), '1');
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ reviewerMaxRounds: { ollama: 1 } }));
});
it('sets a cap for a @username reviewer keyed by its @-form token', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(<ReviewerPicker reviewers={['copilot']} usernames={['flaky-bot']} onChange={onChange} />);
await user.type(screen.getByLabelText('Max review rounds for @flaky-bot'), '3');
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ reviewerMaxRounds: { '@flaky-bot': 3 } }));
});
it('clearing the input DELETES the entry rather than writing 0 (absent ≠ 0)', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(<ReviewerPicker reviewers={['codex', 'ollama']} reviewerMaxRounds={{ ollama: 2 }} onChange={onChange} />);
await user.clear(screen.getByLabelText('Max review rounds for Ollama'));
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ reviewerMaxRounds: {} }));
});
it('clamps a cap above the ceiling instead of sending a value the server would drop', () => {
const onChange = vi.fn();
render(<ReviewerPicker reviewers={['ollama']} onChange={onChange} />);
// fireEvent (not user.type) so the whole out-of-range value lands in one
// change event — a controlled input never accumulates keystrokes.
fireEvent.change(screen.getByLabelText('Max review rounds for Ollama'), { target: { value: '99' } });
expect(onChange).toHaveBeenLastCalledWith(expect.objectContaining({ reviewerMaxRounds: { ollama: 10 } }));
});
it('rejects a negative cap rather than clamping it to 0 (which would mean unlimited)', () => {
const onChange = vi.fn();
render(<ReviewerPicker reviewers={['ollama']} onChange={onChange} />);
fireEvent.change(screen.getByLabelText('Max review rounds for Ollama'), { target: { value: '-2' } });
// Clamping to 0 would silently turn a typo into slashdo's "loop until clean".
expect(onChange).not.toHaveBeenCalled();
});
it('rejects a fractional cap rather than truncating it', () => {
const onChange = vi.fn();
render(<ReviewerPicker reviewers={['ollama']} onChange={onChange} />);
fireEvent.change(screen.getByLabelText('Max review rounds for Ollama'), { target: { value: '1.5' } });
expect(onChange).not.toHaveBeenCalled();
});
it('prunes the cap entry when its reviewer is removed', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(<ReviewerPicker reviewers={['codex', 'ollama']} reviewerMaxRounds={{ ollama: 1 }} onChange={onChange} />);
await user.click(screen.getByLabelText('Remove Ollama'));
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ reviewers: ['codex'], reviewerMaxRounds: {} }));
});
it('prunes the cap entry when its username reviewer is removed', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(<ReviewerPicker reviewers={['copilot']} usernames={['flaky-bot']} reviewerMaxRounds={{ '@flaky-bot': 2 }} onChange={onChange} />);
await user.click(screen.getByLabelText('Remove @flaky-bot'));
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ usernames: [], reviewerMaxRounds: {} }));
});
it('keeps the ~opt toggle and the cap independent', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(<ReviewerPicker reviewers={['ollama']} reviewerMaxRounds={{ ollama: 1 }} onChange={onChange} />);
await user.click(screen.getByLabelText('Make Ollama non-blocking'));
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({
optionalReviewers: ['ollama'],
reviewerMaxRounds: { ollama: 1 }
}));
});
});
describe('per-reviewer Model column', () => {
// Shape mirrors useReviewerModelOptions()' return — the caller owns the fetch.
const modelOptions = {
optionsByReviewer: {
ollama: ['qwen2.5-coder:32b', 'codellama'],
lmstudio: ['local-model-a'],
codex: ['gpt-tier-a', 'gpt-tier-b'],
claude: ['claude-tier-a', 'qwen2.5-coder:32b'],
},
defaultModels: { codex: 'gpt-tier-a' },
freeText: { codex: true, claude: true, lmstudio: false, ollama: false },
unavailable: { lmstudio: false, ollama: false },
loaded: true,
};
it('renders a Model control for each model-taking reviewer', () => {
render(<ReviewerPicker reviewers={['ollama', 'codex', 'copilot']} modelOptions={modelOptions} onChange={() => {}} />);
expect(screen.getByLabelText('Model for Ollama')).toBeInTheDocument();
expect(screen.getByLabelText('Model for Codex')).toBeInTheDocument();
// Copilot has no CLI and takes no model — no control, just the em dash.
expect(screen.queryByLabelText('Model for Copilot')).not.toBeInTheDocument();
});
it('shows the provider default when no per-reviewer model pin exists', () => {
render(<ReviewerPicker reviewers={['codex']} modelOptions={modelOptions} onChange={() => {}} />);
expect(screen.getByLabelText('Model for Codex')).toHaveValue('gpt-tier-a');
expect(screen.getByLabelText('Model for Codex')).toHaveAttribute('title', expect.stringContaining('by default'));
});
it('does not render a Model control for a @username reviewer', () => {
render(<ReviewerPicker reviewers={['copilot']} usernames={['flaky-bot']} modelOptions={modelOptions} onChange={() => {}} />);
expect(screen.queryByLabelText('Model for @flaky-bot')).not.toBeInTheDocument();
});
it('renders a local backend as a closed select of its installed ids', () => {
render(<ReviewerPicker reviewers={['ollama']} modelOptions={modelOptions} onChange={() => {}} />);
const select = screen.getByLabelText('Model for Ollama');
expect(select.tagName).toBe('SELECT');
expect(screen.getByRole('option', { name: 'qwen2.5-coder:32b' })).toBeInTheDocument();
});
it('renders a CLI reviewer as a dropdown of its catalog', () => {
render(<ReviewerPicker reviewers={['claude']} modelOptions={modelOptions} onChange={() => {}} />);
expect(screen.getByLabelText('Model for Claude').tagName).toBe('SELECT');
expect(screen.getByRole('option', { name: 'claude-tier-a' })).toBeInTheDocument();
});
it('offers a CLI reviewer a Custom… escape that swaps in a free-text input', () => {
const onChange = vi.fn();
render(<ReviewerPicker reviewers={['claude']} modelOptions={modelOptions} onChange={onChange} />);
fireEvent.change(screen.getByLabelText('Model for Claude'), { target: { value: '[custom]' } });
// An Ollama-backed / Bedrock-form claude id can't be enumerated, so the
// escape must accept a typed value rather than only a pick.
expect(screen.getByLabelText('Model for Claude').tagName).toBe('INPUT');
// The sentinel is a UI mode, not an id — it must never be stored as a pin.
expect(onChange).not.toHaveBeenCalled();
});
it('does not offer the Custom… escape to a probed local backend', () => {
render(<ReviewerPicker reviewers={['ollama']} modelOptions={modelOptions} onChange={() => {}} />);
// Ollama's list is the daemon's own answer: an id it doesn't list isn't installed.
expect(screen.queryByRole('option', { name: 'Custom…' })).not.toBeInTheDocument();
});
it('leaving an empty Custom… field returns the cell to the dropdown', () => {
render(<ReviewerPicker reviewers={['claude']} modelOptions={modelOptions} onChange={() => {}} />);
fireEvent.change(screen.getByLabelText('Model for Claude'), { target: { value: '[custom]' } });
fireEvent.blur(screen.getByLabelText('Model for Claude'));
expect(screen.getByLabelText('Model for Claude').tagName).toBe('SELECT');
});
it('keeps the Custom… input mounted while a typed id is being edited', () => {
render(<ReviewerPicker reviewers={['claude']} modelOptions={modelOptions} onChange={() => {}} />);
fireEvent.change(screen.getByLabelText('Model for Claude'), { target: { value: '[custom]' } });
// Clearing the field to retype must not swap the control out mid-edit.
fireEvent.change(screen.getByLabelText('Model for Claude'), { target: { value: 'x' } });
fireEvent.change(screen.getByLabelText('Model for Claude'), { target: { value: '' } });
expect(screen.getByLabelText('Model for Claude').tagName).toBe('INPUT');
});
it('keeps a pin outside the catalog editable rather than unpickable', () => {
render(<ReviewerPicker reviewers={['claude']} reviewerModels={{ claude: 'llama3.1:70b' }} modelOptions={modelOptions} onChange={() => {}} />);
const control = screen.getByLabelText('Model for Claude');
expect(control.tagName).toBe('INPUT');
expect(control).toHaveValue('llama3.1:70b');
});
it('falls back to free-text when no options resolved (a closed empty select would be dead)', () => {
render(<ReviewerPicker reviewers={['ollama']} onChange={() => {}} />);
expect(screen.getByLabelText('Model for Ollama').tagName).toBe('INPUT');
});
it('shows an existing pin', () => {
render(<ReviewerPicker reviewers={['ollama']} reviewerModels={{ ollama: 'codellama' }} modelOptions={modelOptions} onChange={() => {}} />);
expect(screen.getByLabelText('Model for Ollama')).toHaveValue('codellama');
});
it('keeps an option for a pin the probe no longer lists', () => {
render(<ReviewerPicker reviewers={['ollama']} reviewerModels={{ ollama: 'uninstalled-model' }} modelOptions={modelOptions} onChange={() => {}} />);
// Without the synthesized option the select would render blank and read as
// "unset" while the value is in fact stored.
expect(screen.getByLabelText('Model for Ollama')).toHaveValue('uninstalled-model');
expect(screen.getByRole('option', { name: /uninstalled-model \(not installed\)/ })).toBeInTheDocument();
});
it('pins a model for a local reviewer', () => {
const onChange = vi.fn();
render(<ReviewerPicker reviewers={['ollama']} modelOptions={modelOptions} onChange={onChange} />);
fireEvent.change(screen.getByLabelText('Model for Ollama'), { target: { value: 'codellama' } });
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ reviewerModels: { ollama: 'codellama' } }));
});
it('pins a typed model for a CLI reviewer', () => {
const onChange = vi.fn();
render(<ReviewerPicker reviewers={['codex']} modelOptions={modelOptions} onChange={onChange} />);
fireEvent.change(screen.getByLabelText('Model for Codex'), { target: { value: 'gpt-tier-b' } });
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ reviewerModels: { codex: 'gpt-tier-b' } }));
});
it('clearing the field DELETES the pin rather than writing an empty id', () => {
const onChange = vi.fn();
render(<ReviewerPicker reviewers={['codex']} reviewerModels={{ codex: 'gpt-tier-a' }} modelOptions={modelOptions} onChange={onChange} />);
fireEvent.change(screen.getByLabelText('Model for Codex'), { target: { value: '' } });
// `''` would emit a `--model ` with no id; absent means "its own default".
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ reviewerModels: {} }));
});
it('treats a whitespace-only entry as a clear, not a pin', () => {
const onChange = vi.fn();
render(<ReviewerPicker reviewers={['codex']} reviewerModels={{ codex: 'gpt-tier-a' }} modelOptions={modelOptions} onChange={onChange} />);
fireEvent.change(screen.getByLabelText('Model for Codex'), { target: { value: '[custom]' } });
fireEvent.change(screen.getByLabelText('Model for Codex'), { target: { value: ' ' } });
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ reviewerModels: {} }));
});
it('prunes the pin when its reviewer is removed', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(<ReviewerPicker reviewers={['codex', 'ollama']} reviewerModels={{ ollama: 'codellama' }} modelOptions={modelOptions} onChange={onChange} />);
await user.click(screen.getByLabelText('Remove Ollama'));
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ reviewers: ['codex'], reviewerModels: {} }));
});
it('keeps the model pin, the ~opt toggle, and the cap independent', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(
<ReviewerPicker
reviewers={['ollama']}
reviewerModels={{ ollama: 'codellama' }}
reviewerMaxRounds={{ ollama: 1 }}
modelOptions={modelOptions}
onChange={onChange}
/>
);
await user.click(screen.getByLabelText('Make Ollama non-blocking'));
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({
optionalReviewers: ['ollama'],
reviewerMaxRounds: { ollama: 1 },
reviewerModels: { ollama: 'codellama' }
}));
});
it('preserves an untouched pin when another row changes', () => {
const onChange = vi.fn();
render(
<ReviewerPicker
reviewers={['codex', 'ollama']}
reviewerModels={{ codex: 'gpt-tier-a' }}
modelOptions={modelOptions}
onChange={onChange}
/>
);
fireEvent.change(screen.getByLabelText('Model for Ollama'), { target: { value: 'codellama' } });
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({
reviewerModels: { codex: 'gpt-tier-a', ollama: 'codellama' }
}));
});
it('reads a pin case-insensitively (legacy/hand-edited key casing)', () => {
render(<ReviewerPicker reviewers={['codex']} reviewerModels={{ Codex: 'gpt-tier-a' }} modelOptions={modelOptions} onChange={() => {}} />);
expect(screen.getByLabelText('Model for Codex')).toHaveValue('gpt-tier-a');
});
it('strips characters that would corrupt the emitted [model] selector', () => {
const onChange = vi.fn();
render(<ReviewerPicker reviewers={['codex']} modelOptions={modelOptions} onChange={onChange} />);
// `foo]~opt` would close the selector early and leave slashdo reading the
// rest as a suffix; the server drops such an id, so accepting it here would
// show a pin that never persists.
fireEvent.change(screen.getByLabelText('Model for Codex'), { target: { value: '[custom]' } });
fireEvent.change(screen.getByLabelText('Model for Codex'), { target: { value: 'foo]~opt' } });
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ reviewerModels: { codex: 'foo~opt' } }));
});
it('keeps a space in a typed id (slashdo selectors are free-form)', () => {
const onChange = vi.fn();
render(<ReviewerPicker reviewers={['claude']} modelOptions={modelOptions} onChange={onChange} />);
fireEvent.change(screen.getByLabelText('Model for Claude'), { target: { value: '[custom]' } });
fireEvent.change(screen.getByLabelText('Model for Claude'), { target: { value: 'Some Model (High)' } });
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ reviewerModels: { claude: 'Some Model (High)' } }));
});
});
describe('Effort column', () => {
it('offers each reviewer only the tiers its own CLI accepts', () => {
render(<ReviewerPicker reviewers={['antigravity']} onChange={() => {}} />);
const select = screen.getByLabelText('Reasoning effort for Antigravity');
expect(select.tagName).toBe('SELECT');
expect(screen.getByRole('option', { name: 'high' })).toBeInTheDocument();
// agy rejects `--effort max`, so the picker must not offer it.
expect(screen.queryByRole('option', { name: 'max' })).not.toBeInTheDocument();
});
it('offers the wider claude ladder on a claude row', () => {
render(<ReviewerPicker reviewers={['claude']} onChange={() => {}} />);
expect(screen.getByRole('option', { name: 'xhigh' })).toBeInTheDocument();
});
it('tells a cursor row its tier needs a Model pin to reach the CLI', () => {
// cursor-agent has no --effort flag: the level rides inside the model id,
// so a tier with no model is dropped when the invocation is built.
const { rerender } = render(<ReviewerPicker reviewers={['cursor']} reviewerEfforts={{ cursor: 'max' }} onChange={() => {}} />);
expect(screen.getByLabelText('Reasoning effort for Cursor Agent'))
.toHaveAttribute('title', expect.stringContaining('pin a Model too'));
rerender(<ReviewerPicker reviewers={['cursor']} reviewerEfforts={{ cursor: 'max' }} reviewerModels={{ cursor: 'gpt-5' }} onChange={() => {}} />);
expect(screen.getByLabelText('Reasoning effort for Cursor Agent'))
.not.toHaveAttribute('title', expect.stringContaining('pin a Model too'));
});
it('renders no Effort control for a reviewer with no effort knob', () => {
render(<ReviewerPicker reviewers={['copilot']} usernames={['flaky-bot']} onChange={() => {}} />);
expect(screen.queryByLabelText('Reasoning effort for Copilot')).not.toBeInTheDocument();
expect(screen.queryByLabelText('Reasoning effort for @flaky-bot')).not.toBeInTheDocument();
});
it('offers grok its own ladder, which stops short of max', () => {
render(<ReviewerPicker reviewers={['grok']} onChange={() => {}} />);
const select = screen.getByLabelText('Reasoning effort for Grok');
expect([...select.options].map((o) => o.value)).toEqual(['', 'low', 'medium', 'high', 'xhigh']);
});
it('shows an existing pin and emits a picked tier', () => {
const onChange = vi.fn();
render(<ReviewerPicker reviewers={['codex']} reviewerEfforts={{ codex: 'low' }} onChange={onChange} />);
const select = screen.getByLabelText('Reasoning effort for Codex');
expect(select).toHaveValue('low');
fireEvent.change(select, { target: { value: 'high' } });
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ reviewerEfforts: { codex: 'high' } }));
});
it('clearing DELETES the key rather than writing an empty string', () => {
const onChange = vi.fn();
render(<ReviewerPicker reviewers={['codex']} reviewerEfforts={{ codex: 'high' }} onChange={onChange} />);
fireEvent.change(screen.getByLabelText('Reasoning effort for Codex'), { target: { value: '' } });
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ reviewerEfforts: {} }));
});
it('keeps a stored tier the ladder no longer lists visible instead of reading as unset', () => {
render(<ReviewerPicker reviewers={['antigravity']} reviewerEfforts={{ antigravity: 'max' }} onChange={() => {}} />);
const select = screen.getByLabelText('Reasoning effort for Antigravity');
expect(select).toHaveValue('max');
expect(screen.getByRole('option', { name: 'max (unsupported)' })).toBeInTheDocument();
});
it('prunes the effort pin when its reviewer is removed', () => {
const onChange = vi.fn();
render(<ReviewerPicker reviewers={['codex', 'ollama']} reviewerEfforts={{ ollama: 'high' }} onChange={onChange} />);
fireEvent.click(screen.getByLabelText('Remove Ollama'));
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ reviewers: ['codex'], reviewerEfforts: {} }));
});
it('reads a pin case-insensitively, like the sibling maps', () => {
render(<ReviewerPicker reviewers={['codex']} reviewerEfforts={{ Codex: 'high' }} onChange={() => {}} />);
expect(screen.getByLabelText('Reasoning effort for Codex')).toHaveValue('high');
});
// #3733: agy validates the model/effort PAIR, so the ladder narrows by the
// row's pinned model. `modelEffortLevels` is the caller's accessor (see
// useReviewerModelOptions) — stubbed here the way the real hook behaves.
describe('narrowed by the pinned model', () => {
const tiersByModel = {
'gemini-3.1-pro': ['high'],
'gemini-3.6-flash': ['low', 'high'],
'claude-sonnet-4-6': [],
};
const narrowing = {
optionsByReviewer: { antigravity: Object.keys(tiersByModel) },
freeText: { antigravity: true },
unavailable: {},
loaded: true,
modelEffortLevels: (reviewer, model) => (reviewer === 'antigravity'
? (tiersByModel[model] ?? ['low', 'medium', 'high'])
: ['low', 'medium', 'high'])
};
it('offers only the tiers the pinned model actually has', () => {
render(<ReviewerPicker reviewers={['antigravity']} reviewerModels={{ antigravity: 'gemini-3.1-pro' }} modelOptions={narrowing} onChange={() => {}} />);
expect(screen.getByRole('option', { name: 'high' })).toBeInTheDocument();
// The pair agy rejects — the whole point of the narrowing.
expect(screen.queryByRole('option', { name: 'medium' })).not.toBeInTheDocument();
});
it('keeps the full ladder when no model is pinned', () => {
render(<ReviewerPicker reviewers={['antigravity']} modelOptions={narrowing} onChange={() => {}} />);
expect(screen.getByRole('option', { name: 'medium' })).toBeInTheDocument();
});
it('falls back to the static ladder when the caller passes no modelOptions', () => {
render(<ReviewerPicker reviewers={['antigravity']} reviewerModels={{ antigravity: 'gemini-3.1-pro' }} onChange={() => {}} />);
expect(screen.getByRole('option', { name: 'medium' })).toBeInTheDocument();
});
it('drops the Effort control for a pinned model with no tiers at all', () => {
render(<ReviewerPicker reviewers={['antigravity']} reviewerModels={{ antigravity: 'claude-sonnet-4-6' }} modelOptions={narrowing} onChange={() => {}} />);
expect(screen.queryByLabelText('Reasoning effort for Antigravity')).not.toBeInTheDocument();
});
it('still renders a STORED pin under a tier-less model so it stays clearable', () => {
const onChange = vi.fn();
render(<ReviewerPicker reviewers={['antigravity']} reviewerModels={{ antigravity: 'claude-sonnet-4-6' }} reviewerEfforts={{ antigravity: 'high' }} modelOptions={narrowing} onChange={onChange} />);
const select = screen.getByLabelText('Reasoning effort for Antigravity');
expect(select).toHaveValue('high');
fireEvent.change(select, { target: { value: '' } });
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ reviewerEfforts: {} }));
});
it('keeps a stored tier the pinned model dropped visible as unsupported', () => {
render(<ReviewerPicker reviewers={['antigravity']} reviewerModels={{ antigravity: 'gemini-3.1-pro' }} reviewerEfforts={{ antigravity: 'medium' }} modelOptions={narrowing} onChange={() => {}} />);
expect(screen.getByLabelText('Reasoning effort for Antigravity')).toHaveValue('medium');
expect(screen.getByRole('option', { name: 'medium (unsupported)' })).toBeInTheDocument();
});
});
});
describe('defaults-aware emit (#6208)', () => {
const DEFAULTS = {
reviewers: ['copilot'],
usernames: [],
optionalReviewers: [],
reviewerMaxRounds: {},
reviewerModels: {},
reviewerEfforts: {},
stopMode: 'all',
reviewerApplies: false,
};
it('emits the full snapshot when no defaults are provided', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(<ReviewerPicker reviewers={['codex', 'antigravity']} onChange={onChange} />);
await user.click(screen.getByLabelText('Remove Codex'));
expect(onChange).toHaveBeenCalledWith(expect.objectContaining({
reviewers: ['antigravity'],
usernames: [],
optionalReviewers: [],
reviewerMaxRounds: {},
reviewerModels: {},
reviewerEfforts: {},
}));
});
it('omits every key that still equals the defaults when only the stop-mode changes', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(
<ReviewerPicker
reviewers={['codex', 'antigravity']}
stopMode="all"
defaults={{ ...DEFAULTS, reviewers: ['codex', 'antigravity'] }}
onChange={onChange}
/>
);
await user.selectOptions(screen.getByLabelText('Stop mode:'), 'on-clean');
expect(onChange).toHaveBeenCalledTimes(1);
expect(onChange).toHaveBeenCalledWith({ stopMode: 'on-clean' });
});
it('emits only reviewers when one is removed from a seeded list', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(
<ReviewerPicker
reviewers={['codex', 'antigravity']}
defaults={{ ...DEFAULTS, reviewers: ['codex', 'antigravity'] }}
onChange={onChange}
/>
);
await user.click(screen.getByLabelText('Remove Codex'));
expect(onChange).toHaveBeenCalledTimes(1);
expect(onChange).toHaveBeenCalledWith({ reviewers: ['antigravity'] });
});
it('emits an explicitly-emptied map that clears a default pin (absent ≠ empty)', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(
<ReviewerPicker
reviewers={['codex']}
optionalReviewers={['codex']}
defaults={{ ...DEFAULTS, reviewers: ['codex'], optionalReviewers: ['codex'] }}
onChange={onChange}
/>
);
await user.click(screen.getByLabelText('Make Codex blocking'));
expect(onChange).toHaveBeenCalledTimes(1);
expect(onChange).toHaveBeenCalledWith({ optionalReviewers: [] });
});
it('omits a pin map that already matches the defaults when an unrelated control changes', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(
<ReviewerPicker
reviewers={['codex']}
reviewerModels={{ codex: 'gpt-5' }}
defaults={{ ...DEFAULTS, reviewers: ['codex'], reviewerModels: { codex: 'gpt-5' } }}
onChange={onChange}
/>
);
await user.click(screen.getByLabelText('Make Codex non-blocking'));
expect(onChange).toHaveBeenCalledTimes(1);
expect(onChange).toHaveBeenCalledWith({ optionalReviewers: ['codex'] });
});
it('compares membership lists order-insensitively (reviewers stay order-sensitive)', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(
<ReviewerPicker
reviewers={['codex', 'antigravity']}
optionalReviewers={['antigravity', 'codex']}
defaults={{ ...DEFAULTS, reviewers: ['codex', 'antigravity'], optionalReviewers: ['codex', 'antigravity'] }}
onChange={onChange}
/>
);
// Reordering the reviewers IS a change (run order); the same-membership
// optional set in another order is not — only reviewers is emitted.
await user.click(screen.getByLabelText('Move Antigravity earlier'));
expect(onChange).toHaveBeenCalledTimes(1);
expect(onChange).toHaveBeenCalledWith({ reviewers: ['antigravity', 'codex'] });
});
it('compares pin-map keys case-insensitively', async () => {
const onChange = vi.fn();
const user = userEvent.setup();
render(
<ReviewerPicker
reviewers={['codex']}
reviewerModels={{ Codex: 'gpt-5' }}
defaults={{ ...DEFAULTS, reviewers: ['codex'], reviewerModels: { codex: 'gpt-5' } }}
onChange={onChange}
/>
);
await user.click(screen.getByLabelText('Make Codex non-blocking'));
expect(onChange).toHaveBeenCalledTimes(1);
expect(onChange).toHaveBeenCalledWith({ optionalReviewers: ['codex'] });
});
});
});