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_usage_collector.py

View on GitHub
"""The headless collector against the real collector core: only the provider HTTP transport is replaced."""
import io
import json
import sys
import unittest
from contextlib import ExitStack, redirect_stdout
from datetime import datetime, timedelta, timezone
from pathlib import Path
from unittest.mock import patch

import host_policy
import router_test_support as support
import state_upgrade
import usage_cache
import usage_collector as collector
import usage_core
import venice_usage


class Response:
    def __init__(self, payload, status=200):
        self.status, self.headers, self._raw = status, {}, json.dumps(payload).encode()

    def read(self):
        return self._raw

    def __enter__(self):
        return self

    def __exit__(self, *exc):
        return False


class CollectorBase(unittest.TestCase):
    def setUp(self):
        self.addCleanup(usage_core.configure_paths)
        self.root = support.isolated_router_state(self.addCleanup, discovery=False, policy=False)
        patcher = patch.dict(usage_cache.os.environ)     # the fixture pins ROUTER_USAGE_CACHE; a real default install has none
        patcher.start()
        self.addCleanup(patcher.stop)
        usage_cache.os.environ.pop('ROUTER_USAGE_CACHE', None)
        self.home = self.root
        self.state = self.root / '.agent-compass'
        self.cache = self.state / 'usage-cache.json'
        self.profile = self.root / 'host-policy.json'
        self.requests = []
        self.codex_used = 25.0
        usage_core.configure_paths(self.cache, home=self.root, state_dir=self.state)
        stack = ExitStack()
        self.addCleanup(stack.close)
        stack.enter_context(patch.object(collector, 'STATE', self.state))
        stack.enter_context(patch.object(venice_usage, 'key', return_value=None))
        stack.enter_context(patch.object(usage_core.urllib.request, 'urlopen', side_effect=self.transport))
        stack.enter_context(patch.object(host_policy, 'policy_path', return_value=(self.profile, False)))
        # No agy CLI, no Pi: only the credentials a test writes exist.
        stack.enter_context(patch.object(usage_core, 'find_antigravity_cli', return_value=None))

    def transport(self, request, timeout=None):
        url = request.full_url
        self.requests.append(url)
        now = datetime.now(timezone.utc)
        if 'chatgpt.com' in url:
            return Response({'plan_type': 'plus', 'rate_limit': {'primary_window': {
                'used_percent': self.codex_used, 'limit_window_seconds': 18000, 'reset_at': (now + timedelta(hours=3)).timestamp()}}})
        if 'api.anthropic.com/api/oauth/usage' in url:
            return Response({'five_hour': {'utilization': 10, 'resets_at': (now + timedelta(hours=2)).isoformat()}})
        raise AssertionError(f'unexpected request {url}')

    def sign_in(self, *names):
        for name in names:
            if name == 'codex':
                (self.root / '.codex').mkdir(exist_ok=True)
                (self.root / '.codex' / 'auth.json').write_text(json.dumps({'tokens': {'access_token': 'codex-token'}}))
            if name == 'claude':
                (self.root / '.claude').mkdir(exist_ok=True)
                (self.root / '.claude' / '.credentials.json').write_text(json.dumps({'claudeAiOauth': {'accessToken': 'claude-token'}}))

    def hosts(self):
        return sorted({url.split('/')[2] for url in self.requests})


class CollectorTests(CollectorBase):
    def test_the_collector_modules_do_not_import_the_optional_plugin(self):
        import ast
        import importlib
        forbidden = {'usage_float', 'usage_lock', 'magpie_usage', 'plugins'}
        for module in (usage_core, collector, usage_cache, venice_usage, sys.modules['usage_magpie']):
            tree = ast.parse(Path(module.__file__).read_text(encoding='utf-8'))
            imported = {alias.name.split('.')[0] for node in ast.walk(tree) if isinstance(node, ast.Import) for alias in node.names}
            imported |= {node.module.split('.')[0] for node in ast.walk(tree) if isinstance(node, ast.ImportFrom) and node.module}
            self.assertEqual(imported & forbidden, set(), module.__name__)
        with patch.dict(sys.modules):
            for name in ('usage_float', 'usage_collector', 'usage_core', 'usage_cache', 'venice_usage', 'usage_magpie'):
                sys.modules.pop(name, None)
            importlib.import_module('usage_collector')
            self.assertNotIn('usage_float', sys.modules)

    def test_collects_every_signed_in_account_and_writes_the_canonical_cache(self):
        self.sign_in('codex', 'claude')
        result = collector.collect()
        self.assertEqual(result['collection_mode'], 'direct')
        self.assertEqual(result['cache_path'], str(self.cache))
        self.assertEqual(sorted(result['providers']), ['claude', 'codex'])
        self.assertEqual(result['not_detected'], ['grok', 'antigravity'])
        self.assertEqual(self.hosts(), ['api.anthropic.com', 'chatgpt.com'])
        document = json.loads(self.cache.read_text(encoding='utf-8'))
        self.assertEqual(document['providers']['codex']['windows'][0]['used_pct'], 25.0)
        self.assertTrue((self.state / 'usage-collector.json').is_file())
        self.assertFalse((self.root / '.usage-float').exists())

    def test_host_policy_subset_collects_only_the_allowed_providers(self):
        self.sign_in('codex', 'claude')
        self.profile.write_text(json.dumps({'allowed_accounts': ['codex', 'antigravity', 'dot', 'chatgpt-web'],
                                            'judges': ['codex'], 'usage_providers': ['codex', 'antigravity']}))
        result = collector.collect()
        self.assertEqual(result['requested_providers'], ['codex', 'antigravity'])
        self.assertEqual(sorted(result['providers']), ['codex'])
        self.assertEqual(self.hosts(), ['chatgpt.com'])        # claude is signed in but not allowed on this host

    def test_dispatch_excluded_accounts_still_collect_usage_unless_usage_providers_narrows(self):
        self.sign_in('codex', 'claude')
        # Excluding accounts from dispatch (`allowed_accounts`) keeps usage collection enabled for signed-in accounts.
        self.profile.write_text('{"allowed_accounts":[]}')
        result = collector.collect()
        self.assertEqual(sorted(result['providers']), ['claude', 'codex'])
        self.assertEqual(self.hosts(), ['api.anthropic.com', 'chatgpt.com'])

        # Only an explicit `usage_providers` list narrows usage collection.
        self.requests.clear()
        self.profile.write_text('{"allowed_accounts":["codex","claude"],"usage_providers":[]}')
        narrowed = collector.collect()
        self.assertEqual((narrowed['requested_providers'], narrowed['providers'], self.requests), ([], {}, []))

    def test_invalid_policy_fetches_nothing_and_raises(self):
        self.sign_in('codex')
        self.profile.write_text('{"allow_accounts":["codex"]}')
        with self.assertRaises(host_policy.HostPolicyError):
            collector.collect()
        self.assertEqual(self.requests, [])
        self.assertFalse(self.cache.exists())

    def test_an_account_without_credentials_is_reported_not_marked_stale(self):
        self.sign_in('codex')
        result = collector.collect()
        self.assertEqual(sorted(result['providers']), ['codex'])
        self.assertEqual(result['not_detected'], ['claude', 'grok', 'antigravity'])
        self.assertEqual(sorted(json.loads(self.cache.read_text())['providers']), ['codex'])

    def test_discovery_includes_named_claude_and_codex_homes(self):
        (self.root / '.claude-work').mkdir()
        (self.root / '.codex-lab').mkdir()
        self.assertEqual(collector.discovered_subscriptions(),
                         ['claude', 'claude-work', 'codex', 'codex-lab', 'grok', 'antigravity'])

    def test_a_pooled_account_collects_its_source_meter_when_only_it_is_listed_in_usage_providers(self):
        self.sign_in('codex')
        self.profile.write_text(json.dumps({'allowed_accounts': ['codex-alias'], 'usage_providers': ['codex-alias']}))
        with patch.object(collector.account_fleet, 'load_accounts', return_value={'quota_sources': {'codex-alias': 'codex'}}):
            result = collector.collect()
        self.assertEqual(result['requested_providers'], ['codex'])
        self.assertEqual(sorted(result['providers']), ['codex'])

    def test_second_pass_inside_the_poll_interval_does_not_ask_the_provider_again(self):
        self.sign_in('codex')
        collector.collect()
        first = len(self.requests)
        self.codex_used = 90.0
        collector.collect()
        self.assertEqual(len(self.requests), first)
        self.assertEqual(json.loads(self.cache.read_text())['providers']['codex']['windows'][0]['used_pct'], 25.0)

    def test_forced_refresh_reads_again_past_the_interval(self):
        self.sign_in('codex')
        collector.collect()
        self.codex_used = 90.0
        usage_core.fetch_all(['codex'], force=True)
        self.assertEqual(json.loads(self.cache.read_text())['providers']['codex']['windows'][0]['used_pct'], 90.0)

    def test_cli_force_flag_skips_poll_throttle_but_obeys_claude_429_backoff(self):
        self.sign_in('codex', 'claude')
        collector.collect()
        initial_claude_calls = sum(1 for u in self.requests if 'anthropic.com/api/oauth/usage' in u)
        self.assertEqual(initial_claude_calls, 1)
        self.codex_used = 88.0
        with redirect_stdout(io.StringIO()):
            self.assertEqual(collector.main(['--once', '--force']), 0)
        providers = json.loads(self.cache.read_text())['providers']
        self.assertEqual(providers['codex']['windows'][0]['used_pct'], 88.0)
        self.assertEqual(sum(1 for u in self.requests if 'anthropic.com/api/oauth/usage' in u), 2)

        # Put claude in 429 rate-limit backoff and verify `--once --force` still obeys it without hitting Claude API
        usage_core.set_claude_backoff(provider_id='claude')
        before_claude_calls = sum(1 for u in self.requests if 'anthropic.com/api/oauth/usage' in u)
        self.codex_used = 92.0
        with redirect_stdout(io.StringIO()):
            self.assertEqual(collector.main(['--once', '--force']), 0)
        after_claude_calls = sum(1 for u in self.requests if 'anthropic.com/api/oauth/usage' in u)
        self.assertEqual(after_claude_calls, before_claude_calls)
        providers_after = json.loads(self.cache.read_text())['providers']
        self.assertEqual(providers_after['codex']['windows'][0]['used_pct'], 92.0)
        self.assertIn('限流退避', providers_after['claude'].get('error') or '')

    def test_a_failing_provider_keeps_the_old_stamp_and_marks_the_row_stale(self):
        self.sign_in('codex')
        collector.collect()
        document = json.loads(self.cache.read_text())
        old = (datetime.now(timezone.utc) - timedelta(hours=2)).isoformat()
        document['providers']['codex']['fetched_at'] = old
        document.pop('attempts', None)
        self.cache.write_text(json.dumps(document))
        self.transport = lambda request, timeout=None: Response({'error': 'down'}, 500)
        with patch.object(usage_core.urllib.request, 'urlopen', side_effect=self.transport):
            collector.collect()
        row = json.loads(self.cache.read_text())['providers']['codex']
        self.assertEqual((row['fetched_at'], row['stale']), (old, True))

    def test_main_prints_one_receipt_and_logs_only_the_class_of_a_failure(self):
        self.sign_in('codex')
        out = io.StringIO()
        with redirect_stdout(out):
            self.assertEqual(collector.main(['--once']), 0)
        self.assertEqual(sorted(json.loads(out.getvalue())['providers']), ['codex'])
        self.profile.write_text('{"nope": 1}')
        with redirect_stdout(io.StringIO()):
            self.assertEqual(collector.main(['--once']), 1)
        self.assertIn('requires allowed_accounts', (self.state / 'usage-collector.log').read_text())
        with patch.object(collector, 'collect', side_effect=RuntimeError('secret remote text')), redirect_stdout(io.StringIO()):
            self.assertEqual(collector.main(['--once']), 1)
        self.assertNotIn('secret remote text', (self.state / 'usage-collector.log').read_text())


class CacheIsolationTests(CollectorBase):
    """The collector writes only the canonical cache and ignores ~/.usage-float/usage-cache.json."""

    def legacy_cache(self, **providers):
        path = self.root / '.usage-float' / 'usage-cache.json'
        path.parent.mkdir(parents=True)
        path.write_text(json.dumps({'providers': providers, 'attempts': {}}))
        return path

    def test_first_write_ignores_legacy_usage_float_cache_and_never_writes_it(self):
        self.sign_in('codex')
        fetched = (datetime.now(timezone.utc) - timedelta(minutes=2)).isoformat()
        legacy = self.legacy_cache(grok={'provider_id': 'grok', 'available': True, 'stale': False, 'fetched_at': fetched,
                                         'windows': [{'id': 'credits', 'label': 'c', 'used_pct': 5.0}]})
        before = legacy.read_bytes()
        collector.collect()
        providers = json.loads(self.cache.read_text())['providers']
        self.assertEqual(sorted(providers), ['codex'])
        self.assertEqual(legacy.read_bytes(), before)

    def test_a_corrupt_cache_is_set_aside_not_overwritten_and_not_blocking(self):
        self.sign_in('codex')
        self.state.mkdir(parents=True)
        self.cache.write_text('{not json')
        collector.collect()
        [aside] = self.state.glob('usage-cache.json.corrupt-*')
        self.assertEqual(aside.read_text(), '{not json')
        self.assertEqual(sorted(json.loads(self.cache.read_text())['providers']), ['codex'])

    def test_a_named_cache_is_used_without_seeding(self):
        self.sign_in('codex')
        self.legacy_cache(grok={'provider_id': 'grok', 'available': True, 'stale': False,
                                'fetched_at': datetime.now(timezone.utc).isoformat(), 'windows': []})
        named = self.root / 'named.json'
        with patch.object(usage_core, 'CACHE_PATH', named):
            collector.collect()
        self.assertEqual(sorted(json.loads(named.read_text())['providers']), ['codex'])
        self.assertFalse(self.cache.exists())


class HostedCollectorEntryTests(CollectorBase):
    """Tests for shared target resolution, cached reading freshness, config persistence, and reset endpoints."""

    def test_refresh_providers_shares_target_resolution_and_quota_sources_with_collect(self):
        self.sign_in('codex', 'claude')
        # Dispatch exclusion (`allowed_accounts`) never drops signed-in accounts from forced refresh or HUD selection.
        self.profile.write_text(json.dumps({'allowed_accounts': ['claude']}))
        with patch.object(collector.account_fleet, 'load_accounts', return_value={'quota_sources': {'codex-alias': 'codex'}}), \
                patch.object(collector.account_fleet, 'configured_quota_sources', return_value={'codex-alias': 'codex'}):
            self.assertEqual(collector.filter_permitted_items(['codex:7d', 'claude:5h']), ['codex:7d', 'claude:5h'])
            refreshed = collector.refresh_providers(['codex-alias', 'claude:5h'])
        self.assertEqual([p.provider_id for p in refreshed], ['codex', 'claude'])
        self.assertEqual(self.hosts(), ['api.anthropic.com', 'chatgpt.com'])

        # Explicit `usage_providers` narrows both HUD selection and forced refresh.
        self.requests.clear()
        self.profile.write_text(json.dumps({'allowed_accounts': ['claude'], 'usage_providers': ['codex-alias']}))
        with patch.object(collector.account_fleet, 'load_accounts', return_value={'quota_sources': {'codex-alias': 'codex'}}), \
                patch.object(collector.account_fleet, 'configured_quota_sources', return_value={'codex-alias': 'codex'}):
            self.assertEqual(collector.filter_permitted_items(['codex:7d', 'claude:5h']), ['codex:7d'])
            narrowed = collector.refresh_providers(['codex:7d', 'claude:5h'])
        self.assertEqual([p.provider_id for p in narrowed], ['codex'])
        self.assertEqual(self.hosts(), ['chatgpt.com'])

    def test_read_cached_usage_enforces_poll_max_age_bounds_and_clock_skew(self):
        self.sign_in('codex')
        now = datetime.now(timezone.utc)
        now_ts = now.timestamp()
        key = usage_core.provider_credential_key('codex')
        row = {
            'provider_id': 'codex',
            'display_name': 'codex',
            'available': True,
            'stale': False,
            'fetched_at': (now - timedelta(minutes=20)).isoformat(),
            'credential_key': key,
            'windows': [{'id': 'five_hour', 'label': '5h', 'used_pct': 15.0}],
        }
        self.state.mkdir(parents=True, exist_ok=True)
        # Recent idle cadence decision (1800s + 600s grace = 2400s): 20m old reading is still fresh.
        self.cache.write_text(json.dumps({
            'providers': {'codex': row},
            'poll': {'codex': {'seconds': 1800, 'at': now_ts - 60}},
        }), encoding='utf-8')
        [fresh] = usage_core.read_cached_usage(['codex:7d'], now=now_ts)
        self.assertFalse(fresh['stale'])

        # Expired poll decision ('at' older than REFRESH_SECONDS): falls back to REFRESH_SECONDS -> stale.
        self.cache.write_text(json.dumps({
            'providers': {'codex': row},
            'poll': {'codex': {'seconds': 1800, 'at': now_ts - 900}},
        }), encoding='utf-8')
        [stale_decision] = usage_core.read_cached_usage(['codex:7d'], now=now_ts)
        self.assertTrue(stale_decision['stale'])

        # Out-of-bounds poll seconds (> POLL_MAX_SECONDS): rejected -> stale.
        self.cache.write_text(json.dumps({
            'providers': {'codex': row},
            'poll': {'codex': {'seconds': 99999, 'at': now_ts - 10}},
        }), encoding='utf-8')
        [stale_bounds] = usage_core.read_cached_usage(['codex:7d'], now=now_ts)
        self.assertTrue(stale_bounds['stale'])

        # Future fetched_at (clock skew): marked stale rather than treated as fresh forever.
        future_row = dict(row, fetched_at=(now + timedelta(minutes=5)).isoformat())
        self.cache.write_text(json.dumps({
            'providers': {'codex': future_row},
            'poll': {'codex': {'seconds': 300, 'at': now_ts}},
        }), encoding='utf-8')
        [skewed] = usage_core.read_cached_usage(['codex:7d'], now=now_ts)
        self.assertTrue(skewed['stale'])

        # Fallback to display_snapshots when providers[pid] has no windows.
        self.cache.write_text(json.dumps({
            'providers': {'codex': {'provider_id': 'codex', 'credential_key': key, 'error': 'HTTP 502', 'windows': []}},
            'display_snapshots': {'codex': row},
        }), encoding='utf-8')
        [snap] = usage_core.read_cached_usage(['codex:7d'], now=now_ts)
        self.assertTrue(snap['stale'])
        self.assertEqual(snap['error'], 'HTTP 502')
        self.assertEqual(snap['windows'][0]['used_pct'], 15.0)

    def test_usage_config_keeps_language_and_strips_old_proxy_keys_on_write(self):
        self.state.mkdir(parents=True, exist_ok=True)
        usage_core.write_usage_config({'language': 'en', 'card_width': 999})
        saved = json.loads(usage_core.CONFIG_PATH.read_text(encoding='utf-8'))
        self.assertEqual(saved, {'language': 'en'})
        self.assertEqual(usage_core.read_usage_config()['language'], 'en')
        usage_core.write_usage_config({'llm_proxy_timezone': 'UTC-8'})
        kept = json.loads(usage_core.CONFIG_PATH.read_text(encoding='utf-8'))
        self.assertEqual(kept, {'language': 'en'})
        self.assertNotIn('llm_proxy_timezone', kept)
        usage_core.CONFIG_PATH.write_text(
            json.dumps({'language': 'zh', 'llm_proxy_budget_duration': '7d', 'litellm_proxies': {}}),
            encoding='utf-8',
        )
        raw = usage_core.CONFIG_PATH.read_text(encoding='utf-8')
        loaded = usage_core.read_usage_config()
        self.assertEqual(loaded['language'], 'zh')
        self.assertIn('llm_proxy_budget_duration', loaded)
        self.assertIn('litellm_proxies', loaded)
        self.assertEqual(usage_core.CONFIG_PATH.read_text(encoding='utf-8'), raw)
        issue = state_upgrade.check_usage_config(usage_core.CONFIG_PATH)
        self.assertIn('llm_proxy_budget_duration', issue)
        self.assertIn(state_upgrade.LEGACY_SETTINGS_REASON, issue)
        self.assertIn(state_upgrade.FIX_SETUP, issue)
        usage_core.write_usage_config({'language': 'zh'})
        cleaned = json.loads(usage_core.CONFIG_PATH.read_text(encoding='utf-8'))
        self.assertEqual(cleaned, {'language': 'zh'})

    def test_claude_session_reset_sets_and_obeys_429_backoff(self):
        self.sign_in('claude')
        calls = []

        def rate_limited(url, *, method='GET', body=None, timeout=20.0, home=None):
            calls.append((method, url))
            return 429, {'error': {'message': 'rate limited'}}

        with patch.object(usage_core, 'claude_authorized_json', side_effect=rate_limited):
            block, err = usage_core.fetch_claude_session_reset('claude')
            self.assertIsNone(block)
            self.assertIn('频繁', err or '')
            self.assertTrue(usage_core.claude_in_backoff('claude'))
            self.assertEqual(len(calls), 1)

            # While in backoff, neither 5h reset read nor claim may hit Anthropic again.
            block2, err2 = usage_core.fetch_claude_session_reset('claude')
            claim = usage_core.claim_claude_session_reset('claude')
            self.assertIsNone(block2)
            self.assertIn('退避', err2 or '')
            self.assertFalse(claim['ok'])
            self.assertIn('退避', claim['message'])
            self.assertEqual(len(calls), 1)


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