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

View on GitHub
import base64
from datetime import datetime, timedelta, timezone
import json
import unittest
import urllib.error

import antigravity_plan as plan
from router_test_support import temporary_root


# Token expiries must be in the future by the wall clock (read_token checks them against it).
TOKEN_BASE = datetime.now(timezone.utc).replace(microsecond=0) + timedelta(hours=2)
LIFETIME = 3600


def signed_in(email, generation=0, lifetime=LIFETIME, iat_exp=True):
    """agy's keyring blob for `email`'s token number `generation`: every renewal moves `expiry` on by one lifetime, and
    the id_token carries `iat`/`exp` one lifetime apart unless `iat_exp` is False."""
    expiry = TOKEN_BASE + timedelta(seconds=generation * lifetime)
    claims = {'email': email, **({'iat': int(expiry.timestamp()) - lifetime, 'exp': int(expiry.timestamp())} if iat_exp else {})}
    return lambda: blob(expiry, claims)


def blob(expiry, claims=None):
    token = {'access_token': 'SECRET', 'expiry': expiry.isoformat()}
    if claims:
        encoded = base64.urlsafe_b64encode(json.dumps(claims).encode()).decode().rstrip('=')
        token['id_token'] = f'e30.{encoded}.sig'
    return json.dumps({'token': token, 'auth_method': 'consumer'})


FREE = {'currentTier': {'id': 'free-tier', 'name': 'Antigravity'}}

PRO = {'currentTier': {'id': 'free-tier', 'name': 'Antigravity'},
       'paidTier': {'id': 'g1-pro-tier', 'name': 'Google AI Pro'}}

ULTRA5 = {'currentTier': {'id': 'free-tier', 'name': 'Antigravity'},
          'paidTier': {'id': 'g1-ultra-lite-tier', 'name': 'Google AI Ultra',
                       'upgradeSubscriptionText': 'You can upgrade to a higher Google AI Ultra plan to receive the highest rate limits.'}}

ULTRA = {'currentTier': {'id': 'free-tier', 'name': 'Antigravity'},
         'paidTier': {'id': 'g1-ultra-tier', 'name': 'Google AI Ultra',
                      'upgradeSubscriptionText': 'You are subscribed to the best Google AI plan.'}}


class AntigravityPlanTests(unittest.TestCase):
    def setUp(self):
        self.state = temporary_root(self.addCleanup)
        self.fresh = lambda: blob(datetime.now(timezone.utc) + timedelta(minutes=40))

    def test_paid_tier_is_read_with_agy_token_and_cached(self):
        seen = []
        document = plan.refresh(self.state, read_blob=self.fresh, fetch=lambda token, timeout: seen.append(token) or ULTRA)
        self.assertEqual(seen, ['SECRET'])
        self.assertEqual((document['plan'], document['tier_id'], document['source']), ('Google AI Ultra', 'g1-ultra-tier', 'paidTier'))
        self.assertEqual(plan.cached_plan(self.state), 'g1-ultra-tier')
        self.assertIsNone(plan.cached_state(self.state)['plan_error'])
        self.assertNotIn('SECRET', (self.state / plan.CACHE_FILE).read_text(encoding='utf-8'))

    def test_paid_tier_id_distinguishes_pro_ultra5_and_ultra20_and_surfaces_unreadable_reasons(self):
        # Empty cache before any refresh has no tier and explains why.
        empty_state = plan.cached_state(self.state)
        self.assertIsNone(empty_state['plan'])
        self.assertIn('loadCodeAssist', empty_state['plan_error'])

        # Failed initial read surfaces the error code as plan_error.
        plan.refresh(self.state, read_blob=lambda: None)
        no_login_state = plan.cached_state(self.state)
        self.assertIsNone(no_login_state['plan'])
        self.assertIn('agy_not_signed_in', no_login_state['plan_error'])

        # Both Ultra 5x and Ultra 20x carry paidTier.name "Google AI Ultra"; cached_plan returns paidTier.id.
        for response, expected_id in ((PRO, 'g1-pro-tier'), (ULTRA5, 'g1-ultra-lite-tier'), (ULTRA, 'g1-ultra-tier')):
            plan.refresh(self.state, read_blob=self.fresh, fetch=lambda *_, r=response: r)
            st = plan.cached_state(self.state)
            self.assertEqual(st['plan'], expected_id)
            self.assertIsNone(st['plan_error'])

    def test_current_tier_is_used_without_a_paid_tier(self):
        response = {'currentTier': {'id': 'standard-tier', 'name': 'Antigravity'}}
        self.assertEqual(plan.tier_from(response)['tier_id'], 'standard-tier')
        self.assertIsNone(plan.tier_from({}))

    def test_failures_keep_the_last_good_plan_and_retry_sooner(self):
        plan.refresh(self.state, read_blob=self.fresh, fetch=lambda *_: ULTRA)
        expired = lambda: blob(datetime.now(timezone.utc) - timedelta(minutes=1))
        document = plan.refresh(self.state, read_blob=expired, fetch=lambda *_: self.fail('no call with an expired token'))
        self.assertEqual((document['plan'], document['error']), ('Google AI Ultra', 'agy_token_expired'))

        def rejected(*_):
            raise urllib.error.HTTPError(plan.ENDPOINT, 401, 'unauthorized', {}, None)
        document = plan.refresh(self.state, read_blob=self.fresh, fetch=rejected)
        self.assertEqual((document['plan'], document['error']), ('Google AI Ultra', 'http_401'))
        self.assertEqual(plan.cached_plan(self.state), 'g1-ultra-tier')

        checked = datetime.now(timezone.utc)
        failed = {'plan': 'Google AI Ultra', 'error': 'http_401', 'checked_at': plan._stamp(checked)}
        self.assertFalse(plan.due(failed, checked + timedelta(minutes=10)))
        self.assertTrue(plan.due(failed, checked + timedelta(minutes=plan.RETRY_MINUTES)))
        good = {'plan': 'Google AI Ultra', 'checked_at': plan._stamp(checked)}
        self.assertFalse(plan.due(good, checked + timedelta(hours=plan.INTERVAL_HOURS - 1)))
        self.assertTrue(plan.due(good, checked + timedelta(hours=plan.INTERVAL_HOURS)))
        self.assertTrue(plan.due({}))

    def test_a_lost_sign_in_drops_the_old_tier_at_once(self):
        plan.refresh(self.state, read_blob=self.fresh, fetch=lambda *_: ULTRA)
        self.assertEqual(plan.refresh(self.state, read_blob=lambda: None)['error'], 'agy_not_signed_in')
        self.assertIsNone(plan.cached_plan(self.state))

    def test_a_tier_expires_when_it_cannot_be_read_again(self):
        now = datetime(2026, 11, 7, tzinfo=timezone.utc)
        plan.refresh(self.state, read_blob=self.fresh, fetch=lambda *_: ULTRA, now=now)
        inside, outside = timedelta(hours=plan.PLAN_MAX_AGE_HOURS - 1), timedelta(hours=plan.PLAN_MAX_AGE_HOURS)
        self.assertEqual(plan.cached_plan(self.state, now + inside), 'g1-ultra-tier')
        self.assertIsNone(plan.cached_plan(self.state, now + outside))
        self.assertIn('expired', plan.cached_state(self.state, now + outside)['plan_error'])

    def test_a_tier_with_no_paid_plan_reads_as_free(self):
        now = plan._now()
        (self.state / plan.CACHE_FILE).write_text(json.dumps({
            'plan': 'Antigravity', 'tier_id': 'free-tier', 'source': 'currentTier', 'read_at': plan._stamp(now),
            'free_confirmed': True}), encoding='utf-8')
        self.assertEqual(plan.cached_plan(self.state), 'Free')

    def test_a_free_tier_reported_as_the_paid_tier_still_reads_as_free(self):
        # 2026-11-10: loadCodeAssist returned `paidTier: {id: free-tier, name: Antigravity Starter Quota}`.
        now = datetime(2026, 11, 10, tzinfo=timezone.utc)
        response = {'paidTier': {'id': 'free-tier', 'name': 'Antigravity Starter Quota'}}
        token, renewed = signed_in('only@example.com'), signed_in('only@example.com', generation=1)
        plan.refresh(self.state, read_blob=token, fetch=lambda *_: response, now=now)
        self.assertEqual(plan.read_cache(self.state)['source'], 'paidTier')
        self.assertIsNone(plan.cached_plan(self.state, now))      # one free answer is not yet a lapse
        later = now + timedelta(minutes=5)
        plan.refresh(self.state, read_blob=token, fetch=lambda *_: response, now=later)
        self.assertIsNone(plan.cached_plan(self.state, later))    # the same token again confirms nothing
        self.assertFalse(plan.due(plan.read_cache(self.state), later, reading=plan.reading_of(token())))
        self.assertTrue(plan.due(plan.read_cache(self.state), later, reading=plan.reading_of(renewed())))
        plan.refresh(self.state, read_blob=renewed, fetch=lambda *_: response, now=later)
        self.assertEqual(plan.cached_plan(self.state, later), 'Free')
        # standard-tier can be a paid Code Assist plan: it keeps its tier id so inventory evaluates it against plan-templates.json.
        response = {'paidTier': {'id': 'standard-tier', 'name': 'Gemini Code Assist Standard'}}
        plan.refresh(self.state, read_blob=renewed, fetch=lambda *_: response, now=later)
        self.assertEqual(plan.cached_plan(self.state, later), 'standard-tier')

    def test_the_cache_records_a_digest_of_the_keyring_account_never_the_address(self):
        now = datetime(2026, 11, 11, tzinfo=timezone.utc)
        plan.refresh(self.state, read_blob=signed_in('Paid@Example.com'), fetch=lambda *_: ULTRA, now=now)
        text = (self.state / plan.CACHE_FILE).read_text(encoding='utf-8')
        document = json.loads(text)
        self.assertEqual(document['identity'], plan.identity_of(signed_in('paid@example.com')()))
        self.assertTrue(document['identity'].startswith('sha256:'))
        for secret in ('SECRET', 'example.com', 'Paid'):
            self.assertNotIn(secret, text)

    def test_another_account_in_the_slot_is_re_read_at_once_and_drops_the_old_tier(self):
        now = datetime(2026, 11, 11, tzinfo=timezone.utc)
        paid = signed_in('paid@example.com')
        plan.refresh(self.state, read_blob=paid, fetch=lambda *_: ULTRA, now=now)
        document = plan.read_cache(self.state)
        later = now + timedelta(minutes=1)
        self.assertFalse(plan.due(document, later, reading=plan.reading_of(paid())))
        self.assertTrue(plan.due(document, later, reading=plan.reading_of(signed_in('free@example.com')())))
        # One token lifetime later the new account's own tier replaces the old one; the old account's plan never carries over.
        after = now + timedelta(seconds=LIFETIME + 60)
        plan.refresh(self.state, read_blob=signed_in('free@example.com'), fetch=lambda *_: FREE, now=after)
        document = plan.read_cache(self.state)
        self.assertEqual((document['tier_id'], document['identity']),
                         ('free-tier', plan.identity_of(signed_in('free@example.com')())))
        self.assertIsNone(plan.flapping(document, after))
        self.assertIsNone(plan.cached_plan(self.state, after))     # unconfirmed free answer

    def test_two_accounts_within_the_window_are_flapping_and_no_tier_counts(self):
        # Round 059: the free account's processes refresh at :38, the paid account's at :50.
        start = datetime(2026, 11, 11, 3, 38, tzinfo=timezone.utc)
        free, paid = signed_in('free@example.com'), signed_in('paid@example.com')
        plan.refresh(self.state, read_blob=free, fetch=lambda *_: FREE, now=start)
        self.assertIsNone(plan.cached_plan(self.state, start))
        flip = start + timedelta(minutes=12)
        plan.refresh(self.state, read_blob=paid, fetch=lambda *_: ULTRA, now=flip)
        state = plan.cached_state(self.state, flip)
        self.assertEqual(state['plan'], None)
        # The window is the token's own lifetime (id_token exp - iat), not a set number of minutes.
        self.assertEqual((state['flapping']['accounts'], state['flapping']['window_minutes']), (2, LIFETIME / 60))
        # A free answer at the next flip back, on a renewed token, is still not a lapse: the account is flapping.
        back = start + timedelta(minutes=60)
        free_renewed = signed_in('free@example.com', generation=1)
        plan.refresh(self.state, read_blob=free_renewed, fetch=lambda *_: FREE, now=back)
        self.assertIsNone(plan.cached_plan(self.state, back))
        self.assertTrue(plan.flapping(plan.read_cache(self.state), back))
        self.assertTrue(plan.due(plan.read_cache(self.state), back, reading=plan.reading_of(signed_in('free@example.com', 2)())))
        # Once one account has held the slot for a whole lifetime, its tier counts again.
        settled = back + timedelta(seconds=LIFETIME + 60)
        plan.refresh(self.state, read_blob=signed_in('paid@example.com', generation=2), fetch=lambda *_: ULTRA, now=settled)
        self.assertIsNone(plan.flapping(plan.read_cache(self.state), settled))
        self.assertEqual(plan.cached_plan(self.state, settled), 'g1-ultra-tier')

    def test_without_iat_exp_the_lifetime_is_the_step_between_two_tokens_and_until_then_a_data_error(self):
        now = datetime(2026, 11, 11, tzinfo=timezone.utc)
        first = signed_in('only@example.com', lifetime=1800, iat_exp=False)
        document = plan.refresh(self.state, read_blob=first, fetch=lambda *_: ULTRA, now=now)
        self.assertNotIn('lifetime_seconds', document)
        self.assertIn(plan.LIFETIME_UNREADABLE, plan.cached_state(self.state, now)['data_error'])
        renewed = signed_in('only@example.com', generation=1, lifetime=1800, iat_exp=False)
        document = plan.refresh(self.state, read_blob=renewed, fetch=lambda *_: ULTRA, now=now + timedelta(minutes=30))
        self.assertEqual(document['lifetime_seconds'], 1800)
        self.assertIsNone(plan.cached_state(self.state, now + timedelta(minutes=30))['data_error'])

    def test_background_refresh_needs_agy_and_honours_the_switch(self):
        self.assertIsNone(plan.refresh_in_background(self.state, {'PATH': ''}))
        self.assertIsNone(plan.refresh_in_background(self.state, {'AGENTCOMPASS_ANTIGRAVITY_PLAN': 'off'}))


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