Skip to content

akiiwa-games/AgentCompass / skills/agent-compass

agent-compass

Flagged

Choose owner, model and effort, outbound authorization, advisor use, and continuation for delegated work. Reads local usage and effective account policy, profiles the task with the configured System-One scorer, then allocates a compatible worker. Use for independent worker or advisor work; ordinary local execution needs no routing.

FileKindSize
SKILL.mdskill md5.5 KB
agents/openai.yamlconfig427 B
calibration/README.mdmarkdown55.2 KB
calibration/arena_capture.pyscript14.0 KB
calibration/community.pyscript25.2 KB
calibration/five_axis.pyscript196.4 KB
calibration/measurements.pyscript68.4 KB
calibration/refresh.pyscript48.6 KB
calibration/series.pyscript10.2 KB
calibration/sources.pyscript24.1 KB
calibration/tiers.pyscript14.6 KB
grok-bot/.gitignoreother47 B
grok-bot/dependency_patch.pyscript4.5 KB
grok-bot/install_cli.pyscript3.6 KB
grok-bot/test-recovery.mjsscript8.6 KB
grok-bot/test_install_cli.pyscript4.1 KB
grok-bot/upstream.jsonconfig3.4 KB
references/accounts.jsonconfig155.9 KB
references/classifier-cases.jsonconfig21.5 KB
references/dispatch-lifecycle.mdmarkdown28.9 KB
references/dispatch-rules.mdmarkdown11.3 KB
references/effort-matching.mdmarkdown5.1 KB
references/fast-modes.mdmarkdown3.5 KB
references/five-axis-scores.jsonconfig3.1 MB
references/gemini-decisions-api.mdmarkdown2.9 KB
references/grok-bot.mdmarkdown13.0 KB
references/herdr.mdmarkdown5.1 KB
references/jev-api.mdmarkdown1.6 KB
references/level-3-conversion.jsonconfig2.4 KB
references/model-capabilities.jsonconfig3.6 KB
references/model-capabilities.mdmarkdown14.6 KB
references/parent-address-gate.mdmarkdown10.1 KB
references/plan-templates.jsonconfig13.2 KB
references/provider-discovery.mdmarkdown11.5 KB
references/provider-usage.mdmarkdown4.1 KB
references/public-data.jsonconfig816 B
references/public-measurements.jsonconfig1.3 MB
references/roll-reference.mdmarkdown26.7 KB
references/router-internals.mdmarkdown93.7 KB
references/task-classifier.mdmarkdown6.1 KB
references/user-scores.jsonconfig6.8 KB
references/work-kinds.mdmarkdown4.7 KB
references/worker-communication.mdmarkdown2.1 KB
scripts/account_fleet.pyscript32.9 KB
scripts/account_state.pyscript22.2 KB
scripts/accounts_override.pyscript14.8 KB
scripts/allocator.pyscript19.8 KB
scripts/antigravity_plan.pyscript18.7 KB
scripts/antigravity_telemetry.pyscript5.1 KB
scripts/auto_bundles.pyscript31.3 KB
scripts/axis_scores.pyscript40.3 KB
scripts/caller_input.pyscript3.0 KB
scripts/candidate_eval.pyscript54.0 KB
scripts/candidate_ranking.pyscript9.5 KB
scripts/capability_catalog.pyscript8.0 KB
scripts/check_router_contract.pyscript2.8 KB
scripts/conftest.pyscript2.5 KB
scripts/cwd_policy.pyscript1.5 KB
scripts/data_age.pyscript1.5 KB
scripts/decision_ledger.pyscript18.9 KB
scripts/demo_plan.pyscript6.3 KB
scripts/dispatch_fallback.pyscript40.3 KB
scripts/dispatch_flow.pyscript58.7 KB
scripts/dispatch_ground_truth.pyscript43.5 KB
scripts/dispatch_registry.pyscript113.7 KB
scripts/entry.pyscript1.7 KB
scripts/env_vars.pyscript580 B
scripts/fast_modes.pyscript2.5 KB
scripts/fixtures/grok-api-responses.jsonconfig907 B
scripts/fixtures/reference-accounts.jsonconfig26.9 KB
scripts/grok_bot_paths.pyscript1005 B
scripts/host_herdr.pyscript16.8 KB
scripts/host_placement.pyscript9.4 KB
scripts/host_policy.pyscript10.1 KB
scripts/launch_failures.pyscript5.9 KB
scripts/launch_values.pyscript12.3 KB
scripts/ledger_snapshot.pyscript11.1 KB
scripts/live_models.pyscript21.1 KB
scripts/model_latch.pyscript7.6 KB
scripts/model_resolution.pyscript18.0 KB
scripts/override_store.pyscript2.2 KB
scripts/plan_state_residue.pyscript5.0 KB
scripts/provider_inventory.pyscript128.2 KB
scripts/provider_retry.pyscript34.6 KB
scripts/public_data.pyscript59.2 KB
scripts/quota_economy.pyscript38.0 KB
scripts/quota_exhaustion.pyscript5.9 KB
scripts/quota_overrides.pyscript25.6 KB
scripts/quota_pools.pyscript29.8 KB
scripts/reference_provenance.pyscript32.3 KB
scripts/released_names.pyscript3.8 KB
scripts/roll.pyscript106.3 KB
scripts/route_judge.pyscript83.4 KB
scripts/route_simulation.pyscript26.3 KB
scripts/router_test_support.pyscript6.7 KB
scripts/run_grok_bot.pyscript18.8 KB
scripts/scorer_client.pyscript55.2 KB
scripts/stage_help.pyscript5.8 KB
scripts/state_upgrade.pyscript24.0 KB
scripts/subscription_cli.pyscript3.6 KB
scripts/task_intake.pyscript33.6 KB
scripts/test_account_identity.pyscript7.1 KB
scripts/test_account_state.pyscript63.3 KB
scripts/test_accounts_override.pyscript30.1 KB
scripts/test_allocator.pyscript94.2 KB
scripts/test_antigravity_plan.pyscript13.2 KB
scripts/test_applicable_quota.pyscript9.1 KB
scripts/test_auto_bundles.pyscript10.8 KB
scripts/test_billing_routing_policy.pyscript9.9 KB
scripts/test_cadence_count.pyscript32.2 KB
scripts/test_calibration_units.pyscript27.0 KB
scripts/test_capability_catalog.pyscript5.0 KB
scripts/test_decision_ledger.pyscript8.5 KB
scripts/test_demo_plan.pyscript3.4 KB
scripts/test_derived_state.pyscript21.6 KB
scripts/test_dispatch.pyscript322.3 KB
scripts/test_dispatch_answers.pyscript14.8 KB
scripts/test_dispatch_fallback.pyscript53.2 KB
scripts/test_entry.pyscript1.6 KB
scripts/test_fast_modes.pyscript9.9 KB
scripts/test_five_axis.pyscript290.1 KB
scripts/test_five_axis_economy.pyscript105.0 KB
scripts/test_fleet_parity.pyscript15.6 KB
scripts/test_grok_bot.pyscript47.7 KB
scripts/test_ground_truth_recording.pyscript68.8 KB
scripts/test_herdr.pyscript14.1 KB
scripts/test_host_policy.pyscript24.6 KB
scripts/test_launch_values.pyscript8.0 KB
scripts/test_metered_usd.pyscript60.4 KB
scripts/test_model_resolution.pyscript9.2 KB
scripts/test_named_route_facts.pyscript28.6 KB
scripts/test_native_hosts.pyscript6.0 KB
scripts/test_new_user_fleet.pyscript3.3 KB
scripts/test_no_hardcode_classification.pyscript75.1 KB
scripts/test_no_legacy_scoring.pyscript6.5 KB
scripts/test_override_store.pyscript2.3 KB
scripts/test_plan_says_why.pyscript44.9 KB
scripts/test_provider_inventory.pyscript83.2 KB
scripts/test_provider_names.pyscript126.0 KB
scripts/test_provider_pools.pyscript14.2 KB
scripts/test_public_data.pyscript93.5 KB
scripts/test_quota_exhaustion.pyscript5.6 KB
scripts/test_rate_limit_windows.pyscript6.3 KB
scripts/test_record_says_why.pyscript26.5 KB
scripts/test_reference_provenance.pyscript16.7 KB
scripts/test_refresh_entry.pyscript110.7 KB
scripts/test_released_names.pyscript4.1 KB
scripts/test_reset_priority.pyscript4.8 KB
scripts/test_roll_answers.pyscript44.7 KB
scripts/test_roll_notifications.pyscript10.4 KB
scripts/test_route_judge.pyscript99.8 KB
scripts/test_route_simulation.pyscript7.0 KB
scripts/test_routing_parity.pyscript32.3 KB
scripts/test_routing_review.pyscript25.1 KB
scripts/test_setup_discovery_parity.pyscript9.5 KB
scripts/test_stage_help.pyscript2.0 KB
scripts/test_state_upgrade.pyscript13.8 KB
scripts/test_turn_refusal.pyscript16.7 KB
scripts/test_usage_cache.pyscript4.9 KB
scripts/test_usage_collector.pyscript21.4 KB
scripts/test_usage_core_claude_accounts.pyscript1.8 KB
scripts/test_usage_core_grok_cli_billing.pyscript15.6 KB
scripts/test_usage_core_magpie.pyscript5.4 KB
scripts/test_usage_core_magpie_pool.pyscript10.8 KB
scripts/test_usage_core_safety.pyscript24.4 KB
scripts/test_user_scores.pyscript102.3 KB
scripts/test_venice_usage.pyscript1.3 KB
scripts/test_window_scope.pyscript5.5 KB
scripts/turn_refusal.pyscript10.7 KB
scripts/usage_cache.pyscript4.7 KB
scripts/usage_collector.pyscript7.4 KB
scripts/usage_core.pyscript142.0 KB
scripts/usage_magpie.pyscript10.6 KB
scripts/usage_reading.pyscript17.1 KB
scripts/user_scores.pyscript72.8 KB
scripts/venice_usage.pyscript2.6 KB
scripts/window_scope.pyscript3.2 KB
scripts/worker_context.pyscript8.9 KB
scripts/worker_sessions.pyscript10.9 KB

scripts/test_turn_refusal.py

View on GitHub
"""The continuation verdict follows a new turn's admission: a worker under the context threshold is "same worker" only
when its account and model could take a turn now (dispatch-rules.md section 3), it never writes or waits on a writer, and
it does not depend on the hold a failure records later. Synthetic accounts, usage, holds and registry rows."""
import copy
from datetime import datetime, timedelta, timezone
import sqlite3
import time
import unittest
from unittest.mock import patch

import account_fleet
import dispatch_registry as registry
import host_policy
import model_latch
import provider_retry
import quota_exhaustion
import turn_refusal
import usage_reading
import worker_sessions

from router_test_support import isolated_router_state

NOW = datetime.now(timezone.utc)
THRESHOLD = 2_000_000
BUNDLE = {'account': 'acme', 'provider': 'acme', 'model': 'acme-quartz-2', 'effort': 'high', 'bundle_id': 'quartz_high'}
FLEET = {'accounts': {'acme': {'windows': {'seven_day': {'hours': 168}}, 'bundles': {
    'quartz_high': {'provider': 'acme', 'model': 'acme-quartz-2', 'effort': 'high'},
    'onyx_high': {'provider': 'acme', 'model': 'acme-onyx-2', 'effort': 'high'}}}},
    'scoring': {'rotate_after_carried_tokens': THRESHOLD}, 'families': {'rows': []}, 'provider_names': {'defaults': {}, 'rows': {}},
    '_discovery': {'accounts': {'acme': {'status': 'ready'}}, 'launchers': {}}}


def setUpModule():
    isolated_router_state(unittest.addModuleCleanup)


def usage(left):
    """A fresh reading of the account's one window with `left` percent remaining, resetting in 40 hours."""
    window = usage_reading.window_state({'id': 'seven_day', 'used_pct': 100 - left,
                                       'resets_at': (NOW + timedelta(hours=40)).isoformat()}, NOW)
    return {'accounts': {'acme': {'status': 'fresh', 'fetched_at': NOW.isoformat(), 'available': True,
                                  'windows': [window]}}}


def dispatch_row(dispatch_id='d1', agent_id='worker', **extra):
    now = NOW.isoformat()
    return {'dispatch_id': dispatch_id, 'decision_id': 'dec-' + dispatch_id, 'agent_id': agent_id, 'state': 'started',
            'created_at': now, 'lease_until': (NOW + timedelta(hours=1)).isoformat(), 'expected_usd': 0.0, 'usage': {},
            'bundle': dict(BUNDLE), **extra}


class VerdictTestCase(unittest.TestCase):
    def setUp(self):
        registry.db_path().unlink(missing_ok=True)
        self.fleet = copy.deepcopy(FLEET)
        self.left, self.holds, self.latches, self.policy, self.receipt = 80, {}, {}, None, None
        for new in (patch.object(account_fleet, 'load_accounts', side_effect=lambda: self.fleet),
                    patch.object(usage_reading, 'usage_snapshot', side_effect=lambda *a, **k: usage(self.left)),
                    patch.object(host_policy, 'load_policy', side_effect=lambda: self.policy),
                    patch.object(provider_retry, 'active', side_effect=lambda **k: self.holds),
                    patch.object(model_latch, 'active', side_effect=lambda **k: self.latches),
                    patch.object(registry, 'watcher_receipt', side_effect=lambda dispatch_id: self.receipt),
                    patch.object(registry, 'paseo_agent_record', return_value=None)):
            new.start()
            self.addCleanup(new.stop)
        self.store(dispatch_row())

    def store(self, *rows):
        with registry.transaction() as connection:
            for row in rows:
                registry.save(connection, row)

    def verdict(self, carried=500_000):
        with patch.object(worker_sessions, 'session_state', return_value={'compacted_tokens': 0, 'context_tokens': carried}):
            return worker_sessions.continuation_verdict('worker').splitlines()[0]

    def assertRoll(self, verdict, *words):
        self.assertTrue(verdict.startswith('Continuation: roll'), verdict)
        for word in words:
            self.assertIn(word, verdict)

    def assertSame(self, verdict):
        self.assertTrue(verdict.startswith('Continuation: same worker'), verdict)


class ContinuationVerdictTests(VerdictTestCase):
    def test_under_the_threshold_with_a_ready_account_is_the_same_worker(self):
        self.assertTrue(self.verdict().startswith('Continuation: same worker (carried 500,000 of 2,000,000'))

    def test_an_exhausted_window_names_the_window_and_rolls(self):
        self.left = 0
        self.assertRoll(self.verdict(), 'seven_day', 'acme')

    def test_a_provider_hold_on_the_account_rolls(self):
        self.holds = {provider_retry.key('acme'): {
            'account': 'acme', 'scope': 'account', 'failure_code': provider_retry.TURN_FAILED_CODE,
            'message': 'Individual quota reached', 'retry_at': None}}
        self.assertRoll(self.verdict(), 'held after a provider failure', 'Individual quota reached')

    def test_a_hold_on_a_quota_pool_of_the_account_refuses_only_the_bundles_drawing_it(self):
        pool = {'id': '3p-5h+3p-weekly', 'models': ['acme-quartz-2']}
        self.holds = {provider_retry.pool_key('acme', pool['id']): {
            'account': 'acme', 'model': None, 'scope': 'account', 'pool': pool,
            'failure_code': provider_retry.TURN_FAILED_CODE, 'message': 'Individual quota reached. Resets in 122h48m2s.'}}
        self.assertRoll(self.verdict(), 'quota pool 3p-5h+3p-weekly', 'Individual quota reached')
        self.store(dispatch_row('d2', 'worker', created_at=(NOW + timedelta(seconds=5)).isoformat(),
                                bundle=dict(BUNDLE, model='acme-onyx-2', bundle_id='onyx_high')))
        self.assertSame(self.verdict())

    def test_a_hold_on_the_model_rolls(self):
        self.latches = {model_latch.key('acme', 'acme-quartz-2'): {
            'account': 'acme', 'model': 'acme-quartz-2', 'code': 'model_not_found', 'observed_at': NOW.isoformat()}}
        self.assertRoll(self.verdict(), 'acme-quartz-2', 'is held')

    def test_a_hold_on_another_model_does_not_refuse_this_worker(self):
        self.latches = {model_latch.key('acme', 'acme-onyx-2'): {
            'account': 'acme', 'model': 'acme-onyx-2', 'code': 'model_not_found', 'observed_at': NOW.isoformat()}}
        self.assertSame(self.verdict())

    def test_an_account_that_is_not_ready_rolls(self):
        self.fleet['_discovery']['accounts']['acme'] = {'status': 'auth_failed', 'reason': 'credentials_rejected'}
        self.assertRoll(self.verdict(), 'not ready', 'credentials_rejected')

    def test_preference_switches_do_not_refuse_a_turn_and_leftover_meter_fields_do(self):
        # Continuing a worker is not choosing its account or model: an account out of automatic routing and a model
        # unchecked since the launch neither roll the verdict nor refuse the gate's turn; leftover meter fields are a
        # fact and do both, so the verdict and the gate agree (turn_refusal.py docstring).
        for name, change, refused in (
                ('out of automatic routing', lambda: setattr(self, 'policy', {'allowed_accounts': ['other']}), False),
                ('unchecked', lambda: [b.update(disabled=True) for b in self.fleet['accounts']['acme']['bundles'].values()],
                 False),
                ('legacy', lambda: self.fleet['accounts']['acme'].update(legacy_meter='retired meter'), True)):
            with self.subTest(name=name):
                self.setUp()
                change()
                gate = turn_refusal.gate_refusal('worker', now=NOW)
                if refused:
                    self.assertRoll(self.verdict(), 'retired meter', 'agentcompass setup', 'roll the follow-up')
                    self.assertIn('retired meter', gate)
                else:
                    self.assertSame(self.verdict())
                    self.assertIsNone(gate)

    def test_over_the_threshold_stays_a_rotate_verdict_whatever_the_account_state(self):
        for state in ('ready', 'exhausted', 'held', 'not_ready'):
            with self.subTest(state=state):
                self.left = 0 if state == 'exhausted' else 80
                self.holds = ({provider_retry.key('acme'): {'account': 'acme', 'scope': 'account', 'retry_at': None}}
                              if state == 'held' else {})
                self.fleet['_discovery']['accounts']['acme'] = (
                    {'status': 'auth_failed', 'reason': 'x'} if state == 'not_ready' else {'status': 'ready'})
                with patch.object(turn_refusal, 'worker_refusal', side_effect=AssertionError('not asked')):
                    self.assertTrue(self.verdict(THRESHOLD).startswith('Continuation: rotate'), state)

    def test_an_unreadable_account_check_is_unknown_never_same_worker(self):
        with patch.object(turn_refusal, 'worker_refusal', side_effect=OSError('state locked')):
            verdict = self.verdict()
        self.assertTrue(verdict.startswith('Continuation: unknown (turn_check_unavailable'), verdict)


class OwnFailureTests(VerdictTestCase):
    """The failed turn the notification reports is read from the receipt (or the settled row), never from the hold that
    a later settlement records: the first verdict after the failure already says roll."""

    FAILED = {'terminal': {'reason': 'error', 'failure_code': provider_retry.TURN_FAILED_CODE,
                           'provider_message': 'Individual quota reached. Resets in 122h48m2s.'}}

    def test_a_provider_failure_in_the_receipt_rolls_before_any_hold_exists(self):
        self.receipt, self.holds = self.FAILED, {}
        self.assertRoll(self.verdict(), 'last turn ended in a provider failure', 'Individual quota reached')

    def test_the_same_failure_settled_on_the_row_rolls(self):
        self.store(dispatch_row(state='failed', failure_code=provider_retry.TURN_FAILED_CODE))
        self.assertRoll(self.verdict(), 'last turn ended in a provider failure')

    def test_a_failure_the_classifier_read_as_the_workers_own_does_not_refuse(self):
        self.store(dispatch_row(state='failed', failure_code=provider_retry.WORKER_TURN_FAILED_CODE))
        self.receipt = self.FAILED
        self.assertSame(self.verdict())

    def test_a_turn_that_ended_without_a_provider_failure_does_not_refuse(self):
        self.receipt = {'terminal': {'reason': 'finished'}}
        self.assertSame(self.verdict())

    def test_the_verdict_never_records_the_hold_itself(self):
        self.receipt = self.FAILED
        with patch.object(provider_retry, 'record', side_effect=AssertionError('verdict wrote a hold')):
            self.assertRoll(self.verdict())


class UnresolvedWorkerTests(VerdictTestCase):
    def test_a_worker_with_no_dispatch_row_is_unknown_never_same_worker(self):
        registry.db_path().unlink()
        verdict = self.verdict()
        self.assertTrue(verdict.startswith('Continuation: unknown (turn_check_unavailable: worker_not_resolvable'), verdict)

    def test_a_row_of_another_worker_does_not_resolve_this_one(self):
        registry.db_path().unlink()
        self.store(dispatch_row('d9', 'someone-else'))
        self.assertIn('worker_not_resolvable', self.verdict())

    def test_the_dispatch_label_resolves_a_worker_whose_row_has_no_agent_id_yet(self):
        registry.db_path().unlink()
        self.store(dispatch_row('d1', None))
        with patch.object(registry, 'paseo_agent_record', return_value={'labels': {'router.dispatch_id': 'd1'}}):
            self.assertSame(self.verdict())

    def test_the_row_of_the_current_attempt_names_the_account(self):
        later = (NOW + timedelta(seconds=5)).isoformat()
        self.store(dispatch_row('d2', 'worker', created_at=later, bundle=dict(BUNDLE, account='other', provider='other', bundle_id='x')))
        self.fleet['accounts']['other'] = {'bundles': {}}
        self.fleet['_discovery']['accounts']['other'] = {'status': 'auth_failed', 'reason': 'x'}
        self.assertRoll(self.verdict(), 'account other is not ready')


class OwnReservationTests(unittest.TestCase):
    """One function drops the worker's own reservation for the gate and the verdict: one naming its agent id, or naming
    no agent id and carrying its dispatch label. One naming another agent id is never its own."""

    def kept(self, records, dispatch_id=None, agent_id=None):
        return [r['dispatch_id'] for r in turn_refusal.without_own(records, dispatch_id, agent_id) if isinstance(r, dict)]

    def test_own_is_its_agent_id_or_an_unbound_reservation_with_its_dispatch_label(self):
        records = [{'dispatch_id': 'mine', 'agent_id': None}, {'dispatch_id': 'bound', 'agent_id': 'worker'},
                   {'dispatch_id': 'other', 'agent_id': 'someone'}]
        self.assertEqual(self.kept(records, 'mine', 'worker'), ['other'])
        self.assertEqual(self.kept(records, 'mine'), ['bound', 'other'])
        self.assertEqual(self.kept(records, None, 'worker'), ['mine', 'other'])
        self.assertEqual(self.kept(records), ['mine', 'bound', 'other'])
        self.assertEqual(turn_refusal.without_own(['not-a-dict']), ['not-a-dict'])

    def test_a_reservation_naming_another_agent_is_never_excluded_by_the_dispatch_label(self):
        # A worker labelled with another dispatch's id, and a second worker carrying the same dispatch id.
        records = [{'dispatch_id': 'shared', 'agent_id': 'second-worker'}, {'dispatch_id': 'shared', 'agent_id': 'worker'}]
        self.assertEqual([r['agent_id'] for r in turn_refusal.without_own(records, 'shared', 'worker')], ['second-worker'])
        self.assertEqual([r['agent_id'] for r in turn_refusal.without_own(records, 'shared', None)],
                         ['second-worker', 'worker'])

    def test_the_verdict_leaves_out_the_row_of_its_own_worker_and_counts_the_others(self):
        class Quiet(VerdictTestCase):
            def runTest(self):
                pass
        case = Quiet()
        case.setUp()
        try:
            case.store(dispatch_row('d2', 'other-worker'))
            with patch.object(turn_refusal, 'window_refusal', return_value=None) as window:
                self.assertIsNone(turn_refusal.worker_refusal('worker', NOW))
            self.assertEqual([r['dispatch_id'] for r in window.call_args.args[4]], ['d2'])
        finally:
            case.doCleanups()


class ReadOnlyTests(VerdictTestCase):
    def test_the_verdict_writes_nothing_and_calls_no_writer_or_classifier(self):
        self.receipt = OwnFailureTests.FAILED
        before = registry.db_path().read_bytes()
        forbidden = {name: AssertionError(f'verdict called {name}') for name in ('reservations', 'inspect', 'transaction')}
        with patch.object(registry, 'reservations', side_effect=forbidden['reservations']), \
                patch.object(registry, 'inspect', side_effect=forbidden['inspect']), \
                patch.object(registry, 'transaction', side_effect=forbidden['transaction']), \
                patch.object(provider_retry, 'record', side_effect=AssertionError('record')), \
                patch.object(provider_retry, 'classify_scope', side_effect=AssertionError('classifier')):
            self.assertRoll(self.verdict())
            self.receipt = None
            self.assertSame(self.verdict())
        self.assertEqual(registry.db_path().read_bytes(), before)

    def test_a_writer_holding_the_registry_lock_does_not_make_the_verdict_wait(self):
        writer = sqlite3.connect(registry.db_path(), isolation_level=None)
        self.addCleanup(writer.close)
        writer.execute('BEGIN IMMEDIATE')       # a writer mid-transaction: readers still read
        started = time.monotonic()
        self.assertSame(self.verdict())
        self.assertLess(time.monotonic() - started, 3)
        writer.execute('ROLLBACK')

    def test_a_registry_that_stays_locked_is_unknown_within_the_short_wait(self):
        writer = sqlite3.connect(registry.db_path(), isolation_level=None)
        self.addCleanup(writer.close)
        writer.execute('BEGIN EXCLUSIVE')
        started = time.monotonic()
        verdict = self.verdict()
        self.assertLess(time.monotonic() - started, 3)
        self.assertTrue(verdict.startswith('Continuation: unknown (turn_check_unavailable'), verdict)
        writer.execute('ROLLBACK')

    def test_reading_the_exhaustion_latch_for_the_verdict_does_not_clear_it(self):
        observed = (NOW - timedelta(hours=2)).isoformat()
        quota_exhaustion.record('acme', 'Individual quota reached', windows=['seven_day'], at=observed)
        path = quota_exhaustion.store_path()
        before = path.read_text(encoding='utf-8')
        recovered = {'available': True, 'fetched_at': NOW.isoformat(), 'windows': [
            {'id': 'seven_day', 'used_pct': 10, 'resets_at': (NOW + timedelta(hours=40)).isoformat()}]}
        self.assertEqual(quota_exhaustion.exhausted_windows('acme', recovered, now=NOW, read_only=True), set())
        self.assertEqual(path.read_text(encoding='utf-8'), before)
        self.assertEqual(quota_exhaustion.exhausted_windows('acme', recovered, now=NOW), set())     # the gate's read clears
        self.assertNotEqual(path.read_text(encoding='utf-8'), before)


if __name__ == '__main__':
    unittest.main()
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 471kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall