Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

9.3 KB
Raw Blame
import copy
import unittest

from scheduler.instance import load
from scheduler.swarm import ConvertError, convert

POLICY = {
    'models': [
        {'engine': 'claude', 'model': 'opus', 'effort': 'high', 'quality': 3, 'cost': 3, 'enabled': True},
        {'engine': 'codex', 'model': 'default', 'effort': 'default', 'quality': 3, 'cost': 2, 'enabled': True},
        {'engine': 'claude', 'model': 'sonnet', 'effort': 'medium', 'quality': 2, 'cost': 2, 'enabled': True},
        {'engine': 'claude', 'model': 'haiku', 'effort': 'auto', 'quality': 1, 'cost': 1, 'enabled': False},
    ],
    'floor': {'low': 1, 'medium': 2, 'high': 3},
    'quotaReserve': 10,
    'localModels': {'quality': 1, 'enabled': True},
}


def machine(id, name, slots, quotas, local=(), received=1793044800000):
    return {'machineId': id, 'name': name, 'maxAgents': slots, 'engines': ['claude', 'codex', 'cursor'],
            'observation': {'quotas': quotas, 'localModels': list(local), 'receivedAt': received}}


def group(id, title, engine=None, model=None, machine_id=None):
    out = {'id': id, 'title': title, 'brief': '', 'assignment': None}
    if engine:
        out['assignment'] = {'status': 'done', 'configuration': {'engine': engine, 'model': model, 'effort': 'auto'},
                             'execution': {'machineId': machine_id}}
    return out


# The snapshot is read at the latest observation: 2026-10-26T21:00Z (m2); m1 was observed at 20:00Z.
# Codex reports resets in epoch seconds (1793480400 is 2026-10-31T21:00Z, 7200 minutes on), Claude as ISO strings.
WEEKLY_67 = {'engine': 'codex', 'known': True, 'windows': [{'name': '5-hour', 'usedPercent': 20, 'resetsAt': '2026-10-26T22:00:00+00:00'},
                                                           {'name': 'weekly', 'usedPercent': 67, 'resetsAt': 1793480400}]}
STATUS = {'value': {'state': {
    'machines': [
        machine('m1', 'Studio', 16, [{'engine': 'claude', 'known': False, 'windows': []}, WEEKLY_67],
                [{'grid': 'g', 'model': 'deepseek/flash', 'name': 'DeepSeek', 'kind': 'api'}]),
        machine('m2', 'Laptop', 1, [{'engine': 'claude', 'known': True, 'windows': [
            {'name': '5-hour', 'usedPercent': 3, 'resetsAt': '2026-10-26T20:30:00+00:00'},
            {'name': 'weekly', 'usedPercent': 72, 'resetsAt': '2026-10-30T14:59:59+00:00'}]}, WEEKLY_67], received=1793048400000),
        machine('m3', 'Banned', 8, [{'engine': 'claude', 'known': True, 'windows': [{'name': 'weekly', 'usedPercent': 10, 'resetsAt': 1793480400}]}]),
    ],
    'rules': [{'projectId': 'p', 'rule': {'kind': 'machines', 'machineIds': ['m1', 'm2']}, 'text': 'Owner: no Banned for now'}],
    'conversations': [
        group('lead', 'Lead'),
        group('g1', 'Build', 'claude', 'opus', 'm2'),
        group('g2', 'Review: Build', 'codex', 'gpt-6.1-sol', 'm1'),
        group('g3', 'Smoke: DeepSeek on Laptop', 'claude', 'deepseek/flash', 'm2'),
        group('g4', 'Docs', 'claude', 'sonnet', 'm1'),
    ],
}}}
ROUTE_LOG = [
    {'group': 'g1', 'request': {'difficulty': 'high', 'risk': 'high', 'size': 'large', 'kind': 'backend', 'why': 'b'}, 'at': '2026-10-26T10:00:00Z'},
    {'group': '$rg', 'request': {'difficulty': 'medium', 'risk': 'low', 'size': 'small', 'kind': 'review', 'why': 'r'}, 'at': '2026-10-26T11:00:00Z'},
]
CONFIG = {
    'policy': POLICY,
    'assessments': {
        'g2': {'route': 1, 'note': 'matched by time and title'},
        'g4': {'estimate': {'difficulty': 'low', 'risk': 'low', 'size': 'medium', 'kind': 'docs'}, 'note': 'no route request'},
    },
    'deps': {'g2': ['g1']},
    'exclude': {'g3': 'pinned by a person to one machine and model'},
}


class ConvertTest(unittest.TestCase):
    def setUp(self):
        self.out = convert(STATUS, ROUTE_LOG, CONFIG)
        self.inst = load(self.out['instance'])

    def test_machines_keep_their_slots_and_only_the_policy_engines(self):
        self.assertEqual([(m.id, m.name, m.slots, m.engines) for m in self.inst.machines],
                         [('m1', 'Studio', 16, ('claude', 'codex')), ('m2', 'Laptop', 1, ('claude', 'codex')), ('m3', 'Banned', 8, ('claude', 'codex'))])

    def test_enabled_policy_rows_and_the_shared_api_model_become_models(self):
        got = {m.id: (m.engine, m.cost, m.quality['default'], m.concurrency, m.subscription) for m in self.inst.models}
        self.assertEqual(got, {'claude-opus': ('claude', 3, 3, None, True), 'codex-default': ('codex', 2, 3, None, True),
                               'claude-sonnet': ('claude', 2, 2, None, True), 'grid-deepseek/flash': ('claude', 1, 1, 4, False)})

    def test_by_default_the_budget_is_the_start_of_the_night_with_the_actual_picks_spend_added_back(self):
        # g1: large on Opus takes 8 x 3 / 2 = 12 from m2's Claude account; g2: small on Codex takes 1 from the shared one.
        got = sorted((a.members, a.budget) for a in self.inst.accounts)
        self.assertEqual(got, [((('m1', 'codex'), ('m2', 'codex')), {'weekly': 34.0}), ((('m2', 'claude'),), {'weekly': 40.0}),
                               ((('m3', 'claude'),), {'weekly': 90.0})])

    def test_quota_windows_are_read_at_the_snapshot_with_resets_in_minutes_and_a_past_reset_refilled(self):
        got = sorted((a.members, [(w.name, w.left, w.resets_in) for w in a.windows], a.reserve) for a in self.inst.accounts)
        # Weekly left includes what the actual picks spent (start of the night); the 5-hour readings are as read.
        self.assertEqual(got, [
            ((('m1', 'codex'), ('m2', 'codex')), [('5-hour', 80.0, 60), ('weekly', 34.0, 7200)], 0.0),
            ((('m2', 'claude'),), [('5-hour', 100.0, None), ('weekly', 40.0, 5400)], 0.0),
            ((('m3', 'claude'),), [('weekly', 90.0, 7200)], 0.0)])

    def test_added_back_spend_never_takes_a_window_past_full(self):
        # m2's Claude weekly: 5% used, so 95 left; adding back g1's 12 would give 107, more than a window holds.
        status = copy.deepcopy(STATUS)
        status['value']['state']['machines'][1]['observation']['quotas'][0]['windows'][1]['usedPercent'] = 5
        claude = next(a for a in load(convert(status, ROUTE_LOG, CONFIG)['instance']).accounts if a.members == (('m2', 'claude'),))
        self.assertEqual((claude.windows[1].left, claude.budget), (100.0, {'weekly': 100.0}))

    def test_models_carry_the_words_of_the_routes_candidate_title(self):
        got = {m.id: m.label for m in self.inst.models}
        self.assertEqual(got, {'claude-opus': 'Claude opus high', 'codex-default': 'Codex default default',
                               'claude-sonnet': 'Claude sonnet medium', 'grid-deepseek/flash': 'Claude on DeepSeek (API)'})

    def test_a_task_takes_its_assessment_from_the_route_log(self):
        t = self.inst.task('g1')
        self.assertEqual((t.minutes, t.floor, t.kind, t.difficulty, t.spend), (180, 1, 'backend', 'high', {'5-hour': 50, 'weekly': 8}))

    def test_a_hand_matched_request_and_an_estimate_are_used_and_listed_as_estimates(self):
        self.assertEqual(self.inst.task('g2').minutes, 20)
        self.assertEqual(self.inst.task('g4').minutes, 60)
        self.assertEqual(sorted(e['group'] for e in self.out['estimates']), ['g2', 'g4'])

    def test_dependencies_come_from_the_config(self):
        self.assertEqual(self.inst.task('g2').deps, ('g1',))

    def test_a_grid_model_is_its_own_family(self):
        self.assertEqual(self.inst.model('grid-deepseek/flash').family, 'deepseek/flash')

    def test_groups_without_work_and_excluded_groups_are_left_out(self):
        self.assertEqual([t.id for t in self.inst.tasks], ['g1', 'g2', 'g4'])
        self.assertEqual(self.out['excluded'], [{'group': 'g3', 'title': 'Smoke: DeepSeek on Laptop', 'reason': 'pinned by a person to one machine and model'}])

    def test_actual_picks_map_each_assignment_to_its_model_row(self):
        self.assertEqual(self.out['actual'], {'g1': ['m2', 'claude-opus'], 'g2': ['m1', 'codex-default'], 'g4': ['m1', 'claude-sonnet']})

    # Project instructions, phase 4: from a Swarm snapshot every task has floor 1, no `independent_of`, reserve 0 and no
    # machines rule; the solver keeps those fields for bench instances.
    def test_tasks_have_no_floor_or_independence(self):
        self.assertEqual([(t.id, t.floor, t.independent_of) for t in self.inst.tasks], [('g1', 1, ()), ('g2', 1, ()), ('g4', 1, ())])

    def test_owner_rules_leave_no_machine_out(self):
        self.assertEqual([m.id for m in self.inst.machines], ['m1', 'm2', 'm3'])
        self.assertTrue([a for a in self.inst.accounts if a.members == (('m3', 'claude'),)])

    def test_the_budget_is_the_weekly_quota_left(self):
        out = convert(STATUS, ROUTE_LOG, {**CONFIG, 'budget': 'now'})
        got = sorted((tuple(map(tuple, a['members'])), a['reserve'], a['budget']) for a in out['instance']['accounts'])
        self.assertEqual(got, [((('m1', 'codex'), ('m2', 'codex')), 0.0, {'weekly': 33.0}), ((('m2', 'claude'),), 0.0, {'weekly': 28.0}),
                               ((('m3', 'claude'),), 0.0, {'weekly': 90.0})])

    def test_a_dependency_on_an_unknown_group_is_refused(self):
        with self.assertRaisesRegex(ConvertError, 'g2 depends on g9'):
            convert(STATUS, ROUTE_LOG, {**CONFIG, 'deps': {'g2': ['g9']}})

    def test_a_group_with_no_assessment_is_refused(self):
        with self.assertRaisesRegex(ConvertError, 'no assessment for g4'):
            convert(STATUS, ROUTE_LOG, {**CONFIG, 'assessments': {'g2': CONFIG['assessments']['g2']}})


if __name__ == '__main__':
    unittest.main()